com.oracle.truffle.nfi.backend.libffi.CharConversionGen Maven / Gradle / Ivy

Go to download
// CheckStyle: start generated
package com.oracle.truffle.nfi.backend.libffi;

import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.dsl.GeneratedBy;
import com.oracle.truffle.api.interop.UnsupportedTypeException;
import com.oracle.truffle.api.library.DynamicDispatchLibrary;
import com.oracle.truffle.api.library.LibraryExport;
import com.oracle.truffle.api.library.LibraryFactory;
import com.oracle.truffle.api.nodes.NodeCost;
import com.oracle.truffle.nfi.backend.libffi.SerializeArgumentLibrary.CharConversion;
import java.util.concurrent.locks.Lock;

@GeneratedBy(CharConversion.class)
final class CharConversionGen {

    private static final LibraryFactory DYNAMIC_DISPATCH_LIBRARY_ = LibraryFactory.resolve(DynamicDispatchLibrary.class);
    private static final LibraryFactory SERIALIZE_ARGUMENT_LIBRARY_ = LibraryFactory.resolve(SerializeArgumentLibrary.class);

    static  {
        LibraryExport.register(CharConversion.class, new SerializeArgumentLibraryExports());
    }

    private CharConversionGen() {
    }

    @GeneratedBy(CharConversion.class)
    private static final class SerializeArgumentLibraryExports extends LibraryExport {

        private SerializeArgumentLibraryExports() {
            super(SerializeArgumentLibrary.class, Character.class, true, false, 0);
        }

        @Override
        protected SerializeArgumentLibrary createUncached(Object receiver) {
            assert receiver instanceof Character;
            SerializeArgumentLibrary uncached = new Uncached();
            return uncached;
        }

        @Override
        protected SerializeArgumentLibrary createCached(Object receiver) {
            assert receiver instanceof Character;
            return new Cached();
        }

        @GeneratedBy(CharConversion.class)
        private static final class Cached extends SerializeArgumentLibrary {

            @CompilationFinal private volatile int state_0_;
            @Child private SerializeArgumentLibrary putByteNode__putByte_serialize_;
            @Child private SerializeArgumentLibrary putUByteNode__putUByte_serialize_;
            @Child private SerializeArgumentLibrary putShortNode__putShort_serialize_;
            @Child private SerializeArgumentLibrary putUShortNode__putUShort_serialize_;
            @Child private SerializeArgumentLibrary putIntNode__putInt_serialize_;
            @Child private SerializeArgumentLibrary putUIntNode__putUInt_serialize_;
            @Child private SerializeArgumentLibrary putLongNode__putLong_serialize_;
            @Child private SerializeArgumentLibrary putULongNode__putULong_serialize_;
            @Child private SerializeArgumentLibrary putFloatNode__putFloat_serialize_;
            @Child private SerializeArgumentLibrary putDoubleNode__putDouble_serialize_;

            protected Cached() {
            }

            @Override
            public boolean accepts(Object receiver) {
                assert !(receiver instanceof Character) || DYNAMIC_DISPATCH_LIBRARY_.getUncached().dispatch(receiver) == null : "Invalid library export. Exported receiver with dynamic dispatch found but not expected.";
                return receiver instanceof Character;
            }

            @Override
            public void putByte(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b1) != 0 /* is-state_0 putByte(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putByteNode__putByte_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putByte(arg0Value, arg1Value, this.putByteNode__putByte_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putByteNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putByteNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putByteNode__putByte_serialize_.accepts(CharConversion.zero()));
                    this.putByteNode__putByte_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b1 /* add-state_0 putByte(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putByte(arg0Value, arg1Value, this.putByteNode__putByte_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

            @Override
            public NodeCost getCost() {
                int state_0 = this.state_0_;
                if ((state_0 & 0b1) == 0) {
                    return NodeCost.UNINITIALIZED;
                } else {
                    return NodeCost.MONOMORPHIC;
                }
            }

            @Override
            public void putUByte(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b10) != 0 /* is-state_0 putUByte(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putUByteNode__putUByte_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putUByte(arg0Value, arg1Value, this.putUByteNode__putUByte_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putUByteNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putUByteNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putUByteNode__putUByte_serialize_.accepts(CharConversion.zero()));
                    this.putUByteNode__putUByte_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b10 /* add-state_0 putUByte(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putUByte(arg0Value, arg1Value, this.putUByteNode__putUByte_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

            @Override
            public void putShort(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b100) != 0 /* is-state_0 putShort(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putShortNode__putShort_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putShort(arg0Value, arg1Value, this.putShortNode__putShort_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putShortNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putShortNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putShortNode__putShort_serialize_.accepts(CharConversion.zero()));
                    this.putShortNode__putShort_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b100 /* add-state_0 putShort(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putShort(arg0Value, arg1Value, this.putShortNode__putShort_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

            @Override
            public void putUShort(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b1000) != 0 /* is-state_0 putUShort(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putUShortNode__putUShort_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putUShort(arg0Value, arg1Value, this.putUShortNode__putUShort_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putUShortNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putUShortNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putUShortNode__putUShort_serialize_.accepts(CharConversion.zero()));
                    this.putUShortNode__putUShort_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b1000 /* add-state_0 putUShort(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putUShort(arg0Value, arg1Value, this.putUShortNode__putUShort_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

            @Override
            public void putInt(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b10000) != 0 /* is-state_0 putInt(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putIntNode__putInt_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putInt(arg0Value, arg1Value, this.putIntNode__putInt_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putIntNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putIntNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putIntNode__putInt_serialize_.accepts(CharConversion.zero()));
                    this.putIntNode__putInt_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b10000 /* add-state_0 putInt(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putInt(arg0Value, arg1Value, this.putIntNode__putInt_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

            @Override
            public void putUInt(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b100000) != 0 /* is-state_0 putUInt(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putUIntNode__putUInt_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putUInt(arg0Value, arg1Value, this.putUIntNode__putUInt_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putUIntNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putUIntNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putUIntNode__putUInt_serialize_.accepts(CharConversion.zero()));
                    this.putUIntNode__putUInt_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b100000 /* add-state_0 putUInt(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putUInt(arg0Value, arg1Value, this.putUIntNode__putUInt_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

            @Override
            public void putLong(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b1000000) != 0 /* is-state_0 putLong(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putLongNode__putLong_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putLong(arg0Value, arg1Value, this.putLongNode__putLong_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putLongNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putLongNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putLongNode__putLong_serialize_.accepts(CharConversion.zero()));
                    this.putLongNode__putLong_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b1000000 /* add-state_0 putLong(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putLong(arg0Value, arg1Value, this.putLongNode__putLong_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

            @Override
            public void putULong(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b10000000) != 0 /* is-state_0 putULong(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putULongNode__putULong_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putULong(arg0Value, arg1Value, this.putULongNode__putULong_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putULongNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putULongNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putULongNode__putULong_serialize_.accepts(CharConversion.zero()));
                    this.putULongNode__putULong_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b10000000 /* add-state_0 putULong(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putULong(arg0Value, arg1Value, this.putULongNode__putULong_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

            @Override
            public void putFloat(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b100000000) != 0 /* is-state_0 putFloat(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putFloatNode__putFloat_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putFloat(arg0Value, arg1Value, this.putFloatNode__putFloat_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putFloatNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putFloatNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putFloatNode__putFloat_serialize_.accepts(CharConversion.zero()));
                    this.putFloatNode__putFloat_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b100000000 /* add-state_0 putFloat(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putFloat(arg0Value, arg1Value, this.putFloatNode__putFloat_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

            @Override
            public void putDouble(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                assert getRootNode() != null : "Invalid libray usage. Cached library must be adopted by a RootNode before it is executed.";
                Character arg0Value = ((Character) arg0Value_);
                int state_0 = this.state_0_;
                if ((state_0 & 0b1000000000) != 0 /* is-state_0 putDouble(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */) {
                    assert (this.putDoubleNode__putDouble_serialize_.accepts(CharConversion.zero()));
                    CharConversion.putDouble(arg0Value, arg1Value, this.putDoubleNode__putDouble_serialize_);
                    return;
                }
                CompilerDirectives.transferToInterpreterAndInvalidate();
                putDoubleNode_AndSpecialize(arg0Value, arg1Value);
                return;
            }

            private void putDoubleNode_AndSpecialize(Character arg0Value, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                Lock lock = getLock();
                boolean hasLock = true;
                lock.lock();
                try {
                    int state_0 = this.state_0_;
                    // assert (this.putDoubleNode__putDouble_serialize_.accepts(CharConversion.zero()));
                    this.putDoubleNode__putDouble_serialize_ = super.insert((SERIALIZE_ARGUMENT_LIBRARY_.create(CharConversion.zero())));
                    this.state_0_ = state_0 = state_0 | 0b1000000000 /* add-state_0 putDouble(Character, NativeArgumentBuffer, SerializeArgumentLibrary) */;
                    lock.unlock();
                    hasLock = false;
                    CharConversion.putDouble(arg0Value, arg1Value, this.putDoubleNode__putDouble_serialize_);
                    return;
                } finally {
                    if (hasLock) {
                        lock.unlock();
                    }
                }
            }

        }
        @GeneratedBy(CharConversion.class)
        private static final class Uncached extends SerializeArgumentLibrary {

            protected Uncached() {
            }

            @Override
            @TruffleBoundary
            public boolean accepts(Object receiver) {
                assert !(receiver instanceof Character) || DYNAMIC_DISPATCH_LIBRARY_.getUncached().dispatch(receiver) == null : "Invalid library export. Exported receiver with dynamic dispatch found but not expected.";
                return receiver instanceof Character;
            }

            @Override
            public boolean isAdoptable() {
                return false;
            }

            @Override
            public NodeCost getCost() {
                return NodeCost.MEGAMORPHIC;
            }

            @TruffleBoundary
            @Override
            public void putByte(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putByte(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

            @TruffleBoundary
            @Override
            public void putUByte(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putUByte(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

            @TruffleBoundary
            @Override
            public void putShort(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putShort(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

            @TruffleBoundary
            @Override
            public void putUShort(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putUShort(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

            @TruffleBoundary
            @Override
            public void putInt(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putInt(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

            @TruffleBoundary
            @Override
            public void putUInt(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putUInt(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

            @TruffleBoundary
            @Override
            public void putLong(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putLong(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

            @TruffleBoundary
            @Override
            public void putULong(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putULong(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

            @TruffleBoundary
            @Override
            public void putFloat(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putFloat(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

            @TruffleBoundary
            @Override
            public void putDouble(Object arg0Value_, NativeArgumentBuffer arg1Value) throws UnsupportedTypeException {
                // declared: true
                assert this.accepts(arg0Value_) : "Invalid library usage. Library does not accept given receiver.";
                Character arg0Value = ((Character) arg0Value_);
                // assert ((SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())).accepts(CharConversion.zero()));
                CharConversion.putDouble(arg0Value, arg1Value, (SERIALIZE_ARGUMENT_LIBRARY_.getUncached(CharConversion.zero())));
                return;
            }

        }
    }
}