#ifdef GET_OPCODE_NAMES OP_Activate, #endif #ifdef GET_INTERP case OP_Activate: { if (!Activate(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_Activate: Text.Op = PrintName("Activate"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitActivate(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitActivate(const SourceInfo &L) { return emitOp<>(OP_Activate, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitActivate(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Activate(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_ActivateThisField, #endif #ifdef GET_INTERP case OP_ActivateThisField: { const auto V0 = ReadArg(S, PC); if (!ActivateThisField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ActivateThisField: Text.Op = PrintName("ActivateThisField"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitActivateThisField( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitActivateThisField( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ActivateThisField, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitActivateThisField( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ActivateThisField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_AddSint8, OP_AddUint8, OP_AddSint16, OP_AddUint16, OP_AddSint32, OP_AddUint32, OP_AddSint64, OP_AddUint64, OP_AddIntAP, OP_AddIntAPS, OP_AddBool, OP_AddFixedPoint, #endif #ifdef GET_INTERP case OP_AddSint8: { if (!Add(S, OpPC)) return false; continue; } case OP_AddUint8: { if (!Add(S, OpPC)) return false; continue; } case OP_AddSint16: { if (!Add(S, OpPC)) return false; continue; } case OP_AddUint16: { if (!Add(S, OpPC)) return false; continue; } case OP_AddSint32: { if (!Add(S, OpPC)) return false; continue; } case OP_AddUint32: { if (!Add(S, OpPC)) return false; continue; } case OP_AddSint64: { if (!Add(S, OpPC)) return false; continue; } case OP_AddUint64: { if (!Add(S, OpPC)) return false; continue; } case OP_AddIntAP: { if (!Add(S, OpPC)) return false; continue; } case OP_AddIntAPS: { if (!Add(S, OpPC)) return false; continue; } case OP_AddBool: { if (!Add(S, OpPC)) return false; continue; } case OP_AddFixedPoint: { if (!Add(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_AddSint8: Text.Op = PrintName("AddSint8"); break; case OP_AddUint8: Text.Op = PrintName("AddUint8"); break; case OP_AddSint16: Text.Op = PrintName("AddSint16"); break; case OP_AddUint16: Text.Op = PrintName("AddUint16"); break; case OP_AddSint32: Text.Op = PrintName("AddSint32"); break; case OP_AddUint32: Text.Op = PrintName("AddUint32"); break; case OP_AddSint64: Text.Op = PrintName("AddSint64"); break; case OP_AddUint64: Text.Op = PrintName("AddUint64"); break; case OP_AddIntAP: Text.Op = PrintName("AddIntAP"); break; case OP_AddIntAPS: Text.Op = PrintName("AddIntAPS"); break; case OP_AddBool: Text.Op = PrintName("AddBool"); break; case OP_AddFixedPoint: Text.Op = PrintName("AddFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitAddSint8(const SourceInfo &); bool emitAddUint8(const SourceInfo &); bool emitAddSint16(const SourceInfo &); bool emitAddUint16(const SourceInfo &); bool emitAddSint32(const SourceInfo &); bool emitAddUint32(const SourceInfo &); bool emitAddSint64(const SourceInfo &); bool emitAddUint64(const SourceInfo &); bool emitAddIntAP(const SourceInfo &); bool emitAddIntAPS(const SourceInfo &); bool emitAddBool(const SourceInfo &); bool emitAddFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitAdd(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitAdd(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitAddSint8(I); case PT_Uint8: return emitAddUint8(I); case PT_Sint16: return emitAddSint16(I); case PT_Uint16: return emitAddUint16(I); case PT_Sint32: return emitAddSint32(I); case PT_Uint32: return emitAddUint32(I); case PT_Sint64: return emitAddSint64(I); case PT_Uint64: return emitAddUint64(I); case PT_IntAP: return emitAddIntAP(I); case PT_IntAPS: return emitAddIntAPS(I); case PT_Bool: return emitAddBool(I); case PT_FixedPoint: return emitAddFixedPoint(I); default: llvm_unreachable("invalid type: emitAdd"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitAddSint8(const SourceInfo &L) { return emitOp<>(OP_AddSint8, L); } bool ByteCodeEmitter::emitAddUint8(const SourceInfo &L) { return emitOp<>(OP_AddUint8, L); } bool ByteCodeEmitter::emitAddSint16(const SourceInfo &L) { return emitOp<>(OP_AddSint16, L); } bool ByteCodeEmitter::emitAddUint16(const SourceInfo &L) { return emitOp<>(OP_AddUint16, L); } bool ByteCodeEmitter::emitAddSint32(const SourceInfo &L) { return emitOp<>(OP_AddSint32, L); } bool ByteCodeEmitter::emitAddUint32(const SourceInfo &L) { return emitOp<>(OP_AddUint32, L); } bool ByteCodeEmitter::emitAddSint64(const SourceInfo &L) { return emitOp<>(OP_AddSint64, L); } bool ByteCodeEmitter::emitAddUint64(const SourceInfo &L) { return emitOp<>(OP_AddUint64, L); } bool ByteCodeEmitter::emitAddIntAP(const SourceInfo &L) { return emitOp<>(OP_AddIntAP, L); } bool ByteCodeEmitter::emitAddIntAPS(const SourceInfo &L) { return emitOp<>(OP_AddIntAPS, L); } bool ByteCodeEmitter::emitAddBool(const SourceInfo &L) { return emitOp<>(OP_AddBool, L); } bool ByteCodeEmitter::emitAddFixedPoint(const SourceInfo &L) { return emitOp<>(OP_AddFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitAddSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } bool EvalEmitter::emitAddFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Add(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_AddOffsetSint8, OP_AddOffsetUint8, OP_AddOffsetSint16, OP_AddOffsetUint16, OP_AddOffsetSint32, OP_AddOffsetUint32, OP_AddOffsetSint64, OP_AddOffsetUint64, OP_AddOffsetIntAP, OP_AddOffsetIntAPS, OP_AddOffsetBool, OP_AddOffsetFixedPoint, #endif #ifdef GET_INTERP case OP_AddOffsetSint8: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetUint8: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetSint16: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetUint16: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetSint32: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetUint32: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetSint64: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetUint64: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetIntAP: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetIntAPS: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetBool: { if (!AddOffset(S, OpPC)) return false; continue; } case OP_AddOffsetFixedPoint: { if (!AddOffset(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_AddOffsetSint8: Text.Op = PrintName("AddOffsetSint8"); break; case OP_AddOffsetUint8: Text.Op = PrintName("AddOffsetUint8"); break; case OP_AddOffsetSint16: Text.Op = PrintName("AddOffsetSint16"); break; case OP_AddOffsetUint16: Text.Op = PrintName("AddOffsetUint16"); break; case OP_AddOffsetSint32: Text.Op = PrintName("AddOffsetSint32"); break; case OP_AddOffsetUint32: Text.Op = PrintName("AddOffsetUint32"); break; case OP_AddOffsetSint64: Text.Op = PrintName("AddOffsetSint64"); break; case OP_AddOffsetUint64: Text.Op = PrintName("AddOffsetUint64"); break; case OP_AddOffsetIntAP: Text.Op = PrintName("AddOffsetIntAP"); break; case OP_AddOffsetIntAPS: Text.Op = PrintName("AddOffsetIntAPS"); break; case OP_AddOffsetBool: Text.Op = PrintName("AddOffsetBool"); break; case OP_AddOffsetFixedPoint: Text.Op = PrintName("AddOffsetFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitAddOffsetSint8(const SourceInfo &); bool emitAddOffsetUint8(const SourceInfo &); bool emitAddOffsetSint16(const SourceInfo &); bool emitAddOffsetUint16(const SourceInfo &); bool emitAddOffsetSint32(const SourceInfo &); bool emitAddOffsetUint32(const SourceInfo &); bool emitAddOffsetSint64(const SourceInfo &); bool emitAddOffsetUint64(const SourceInfo &); bool emitAddOffsetIntAP(const SourceInfo &); bool emitAddOffsetIntAPS(const SourceInfo &); bool emitAddOffsetBool(const SourceInfo &); bool emitAddOffsetFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitAddOffset(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitAddOffset(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitAddOffsetSint8(I); case PT_Uint8: return emitAddOffsetUint8(I); case PT_Sint16: return emitAddOffsetSint16(I); case PT_Uint16: return emitAddOffsetUint16(I); case PT_Sint32: return emitAddOffsetSint32(I); case PT_Uint32: return emitAddOffsetUint32(I); case PT_Sint64: return emitAddOffsetSint64(I); case PT_Uint64: return emitAddOffsetUint64(I); case PT_IntAP: return emitAddOffsetIntAP(I); case PT_IntAPS: return emitAddOffsetIntAPS(I); case PT_Bool: return emitAddOffsetBool(I); case PT_FixedPoint: return emitAddOffsetFixedPoint(I); default: llvm_unreachable("invalid type: emitAddOffset"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitAddOffsetSint8(const SourceInfo &L) { return emitOp<>(OP_AddOffsetSint8, L); } bool ByteCodeEmitter::emitAddOffsetUint8(const SourceInfo &L) { return emitOp<>(OP_AddOffsetUint8, L); } bool ByteCodeEmitter::emitAddOffsetSint16(const SourceInfo &L) { return emitOp<>(OP_AddOffsetSint16, L); } bool ByteCodeEmitter::emitAddOffsetUint16(const SourceInfo &L) { return emitOp<>(OP_AddOffsetUint16, L); } bool ByteCodeEmitter::emitAddOffsetSint32(const SourceInfo &L) { return emitOp<>(OP_AddOffsetSint32, L); } bool ByteCodeEmitter::emitAddOffsetUint32(const SourceInfo &L) { return emitOp<>(OP_AddOffsetUint32, L); } bool ByteCodeEmitter::emitAddOffsetSint64(const SourceInfo &L) { return emitOp<>(OP_AddOffsetSint64, L); } bool ByteCodeEmitter::emitAddOffsetUint64(const SourceInfo &L) { return emitOp<>(OP_AddOffsetUint64, L); } bool ByteCodeEmitter::emitAddOffsetIntAP(const SourceInfo &L) { return emitOp<>(OP_AddOffsetIntAP, L); } bool ByteCodeEmitter::emitAddOffsetIntAPS(const SourceInfo &L) { return emitOp<>(OP_AddOffsetIntAPS, L); } bool ByteCodeEmitter::emitAddOffsetBool(const SourceInfo &L) { return emitOp<>(OP_AddOffsetBool, L); } bool ByteCodeEmitter::emitAddOffsetFixedPoint(const SourceInfo &L) { return emitOp<>(OP_AddOffsetFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitAddOffsetSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } bool EvalEmitter::emitAddOffsetFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AddOffset(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Addf, #endif #ifdef GET_INTERP case OP_Addf: { const auto V0 = ReadArg(S, PC); if (!Addf(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Addf: Text.Op = PrintName("Addf"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitAddf( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitAddf( uint32_t A0, const SourceInfo &L) { return emitOp(OP_Addf, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitAddf( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Addf(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_Alloc, #endif #ifdef GET_INTERP case OP_Alloc: { const auto V0 = ReadArg(S, PC); if (!Alloc(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Alloc: Text.Op = PrintName("Alloc"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitAlloc( const Descriptor * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitAlloc( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_Alloc, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitAlloc( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Alloc(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_AllocCNSint8, OP_AllocCNUint8, OP_AllocCNSint16, OP_AllocCNUint16, OP_AllocCNSint32, OP_AllocCNUint32, OP_AllocCNSint64, OP_AllocCNUint64, OP_AllocCNIntAP, OP_AllocCNIntAPS, #endif #ifdef GET_INTERP case OP_AllocCNSint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } case OP_AllocCNUint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } case OP_AllocCNSint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } case OP_AllocCNUint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } case OP_AllocCNSint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } case OP_AllocCNUint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } case OP_AllocCNSint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } case OP_AllocCNUint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } case OP_AllocCNIntAP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } case OP_AllocCNIntAPS: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!AllocCN(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_AllocCNSint8: Text.Op = PrintName("AllocCNSint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocCNUint8: Text.Op = PrintName("AllocCNUint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocCNSint16: Text.Op = PrintName("AllocCNSint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocCNUint16: Text.Op = PrintName("AllocCNUint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocCNSint32: Text.Op = PrintName("AllocCNSint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocCNUint32: Text.Op = PrintName("AllocCNUint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocCNSint64: Text.Op = PrintName("AllocCNSint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocCNUint64: Text.Op = PrintName("AllocCNUint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocCNIntAP: Text.Op = PrintName("AllocCNIntAP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocCNIntAPS: Text.Op = PrintName("AllocCNIntAPS"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitAllocCNSint8( const Descriptor * , bool , const SourceInfo &); bool emitAllocCNUint8( const Descriptor * , bool , const SourceInfo &); bool emitAllocCNSint16( const Descriptor * , bool , const SourceInfo &); bool emitAllocCNUint16( const Descriptor * , bool , const SourceInfo &); bool emitAllocCNSint32( const Descriptor * , bool , const SourceInfo &); bool emitAllocCNUint32( const Descriptor * , bool , const SourceInfo &); bool emitAllocCNSint64( const Descriptor * , bool , const SourceInfo &); bool emitAllocCNUint64( const Descriptor * , bool , const SourceInfo &); bool emitAllocCNIntAP( const Descriptor * , bool , const SourceInfo &); bool emitAllocCNIntAPS( const Descriptor * , bool , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitAllocCN(PrimType, const Descriptor *, bool, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitAllocCN(PrimType T0, const Descriptor * A0, bool A1, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitAllocCNSint8(A0, A1, I); case PT_Uint8: return emitAllocCNUint8(A0, A1, I); case PT_Sint16: return emitAllocCNSint16(A0, A1, I); case PT_Uint16: return emitAllocCNUint16(A0, A1, I); case PT_Sint32: return emitAllocCNSint32(A0, A1, I); case PT_Uint32: return emitAllocCNUint32(A0, A1, I); case PT_Sint64: return emitAllocCNSint64(A0, A1, I); case PT_Uint64: return emitAllocCNUint64(A0, A1, I); case PT_IntAP: return emitAllocCNIntAP(A0, A1, I); case PT_IntAPS: return emitAllocCNIntAPS(A0, A1, I); default: llvm_unreachable("invalid type: emitAllocCN"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitAllocCNSint8( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNSint8, A0, A1, L); } bool ByteCodeEmitter::emitAllocCNUint8( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNUint8, A0, A1, L); } bool ByteCodeEmitter::emitAllocCNSint16( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNSint16, A0, A1, L); } bool ByteCodeEmitter::emitAllocCNUint16( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNUint16, A0, A1, L); } bool ByteCodeEmitter::emitAllocCNSint32( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNSint32, A0, A1, L); } bool ByteCodeEmitter::emitAllocCNUint32( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNUint32, A0, A1, L); } bool ByteCodeEmitter::emitAllocCNSint64( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNSint64, A0, A1, L); } bool ByteCodeEmitter::emitAllocCNUint64( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNUint64, A0, A1, L); } bool ByteCodeEmitter::emitAllocCNIntAP( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNIntAP, A0, A1, L); } bool ByteCodeEmitter::emitAllocCNIntAPS( const Descriptor * A0, bool A1, const SourceInfo &L) { return emitOp(OP_AllocCNIntAPS, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitAllocCNSint8( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } bool EvalEmitter::emitAllocCNUint8( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } bool EvalEmitter::emitAllocCNSint16( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } bool EvalEmitter::emitAllocCNUint16( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } bool EvalEmitter::emitAllocCNSint32( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } bool EvalEmitter::emitAllocCNUint32( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } bool EvalEmitter::emitAllocCNSint64( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } bool EvalEmitter::emitAllocCNUint64( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } bool EvalEmitter::emitAllocCNIntAP( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } bool EvalEmitter::emitAllocCNIntAPS( const Descriptor * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocCN(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_AllocNSint8, OP_AllocNUint8, OP_AllocNSint16, OP_AllocNUint16, OP_AllocNSint32, OP_AllocNUint32, OP_AllocNSint64, OP_AllocNUint64, OP_AllocNIntAP, OP_AllocNIntAPS, #endif #ifdef GET_INTERP case OP_AllocNSint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } case OP_AllocNUint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } case OP_AllocNSint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } case OP_AllocNUint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } case OP_AllocNSint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } case OP_AllocNUint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } case OP_AllocNSint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } case OP_AllocNUint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } case OP_AllocNIntAP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } case OP_AllocNIntAPS: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!AllocN(S, OpPC, V0, V1, V2)) return false; continue; } #endif #ifdef GET_DISASM case OP_AllocNSint8: Text.Op = PrintName("AllocNSint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocNUint8: Text.Op = PrintName("AllocNUint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocNSint16: Text.Op = PrintName("AllocNSint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocNUint16: Text.Op = PrintName("AllocNUint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocNSint32: Text.Op = PrintName("AllocNSint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocNUint32: Text.Op = PrintName("AllocNUint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocNSint64: Text.Op = PrintName("AllocNSint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocNUint64: Text.Op = PrintName("AllocNUint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocNIntAP: Text.Op = PrintName("AllocNIntAP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_AllocNIntAPS: Text.Op = PrintName("AllocNIntAPS"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitAllocNSint8( PrimType , const Expr * , bool , const SourceInfo &); bool emitAllocNUint8( PrimType , const Expr * , bool , const SourceInfo &); bool emitAllocNSint16( PrimType , const Expr * , bool , const SourceInfo &); bool emitAllocNUint16( PrimType , const Expr * , bool , const SourceInfo &); bool emitAllocNSint32( PrimType , const Expr * , bool , const SourceInfo &); bool emitAllocNUint32( PrimType , const Expr * , bool , const SourceInfo &); bool emitAllocNSint64( PrimType , const Expr * , bool , const SourceInfo &); bool emitAllocNUint64( PrimType , const Expr * , bool , const SourceInfo &); bool emitAllocNIntAP( PrimType , const Expr * , bool , const SourceInfo &); bool emitAllocNIntAPS( PrimType , const Expr * , bool , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitAllocN(PrimType, PrimType, const Expr *, bool, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitAllocN(PrimType T0, PrimType A0, const Expr * A1, bool A2, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitAllocNSint8(A0, A1, A2, I); case PT_Uint8: return emitAllocNUint8(A0, A1, A2, I); case PT_Sint16: return emitAllocNSint16(A0, A1, A2, I); case PT_Uint16: return emitAllocNUint16(A0, A1, A2, I); case PT_Sint32: return emitAllocNSint32(A0, A1, A2, I); case PT_Uint32: return emitAllocNUint32(A0, A1, A2, I); case PT_Sint64: return emitAllocNSint64(A0, A1, A2, I); case PT_Uint64: return emitAllocNUint64(A0, A1, A2, I); case PT_IntAP: return emitAllocNIntAP(A0, A1, A2, I); case PT_IntAPS: return emitAllocNIntAPS(A0, A1, A2, I); default: llvm_unreachable("invalid type: emitAllocN"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitAllocNSint8( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNSint8, A0, A1, A2, L); } bool ByteCodeEmitter::emitAllocNUint8( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNUint8, A0, A1, A2, L); } bool ByteCodeEmitter::emitAllocNSint16( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNSint16, A0, A1, A2, L); } bool ByteCodeEmitter::emitAllocNUint16( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNUint16, A0, A1, A2, L); } bool ByteCodeEmitter::emitAllocNSint32( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNSint32, A0, A1, A2, L); } bool ByteCodeEmitter::emitAllocNUint32( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNUint32, A0, A1, A2, L); } bool ByteCodeEmitter::emitAllocNSint64( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNSint64, A0, A1, A2, L); } bool ByteCodeEmitter::emitAllocNUint64( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNUint64, A0, A1, A2, L); } bool ByteCodeEmitter::emitAllocNIntAP( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNIntAP, A0, A1, A2, L); } bool ByteCodeEmitter::emitAllocNIntAPS( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { return emitOp(OP_AllocNIntAPS, A0, A1, A2, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitAllocNSint8( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitAllocNUint8( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitAllocNSint16( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitAllocNUint16( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitAllocNSint32( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitAllocNUint32( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitAllocNSint64( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitAllocNUint64( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitAllocNIntAP( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitAllocNIntAPS( PrimType A0, const Expr * A1, bool A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return AllocN(S, OpPC, A0, A1, A2); } #endif #ifdef GET_OPCODE_NAMES OP_ArrayDecay, #endif #ifdef GET_INTERP case OP_ArrayDecay: { if (!ArrayDecay(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_ArrayDecay: Text.Op = PrintName("ArrayDecay"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitArrayDecay(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitArrayDecay(const SourceInfo &L) { return emitOp<>(OP_ArrayDecay, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitArrayDecay(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayDecay(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_ArrayElemSint8, OP_ArrayElemUint8, OP_ArrayElemSint16, OP_ArrayElemUint16, OP_ArrayElemSint32, OP_ArrayElemUint32, OP_ArrayElemSint64, OP_ArrayElemUint64, OP_ArrayElemIntAP, OP_ArrayElemIntAPS, OP_ArrayElemBool, OP_ArrayElemFixedPoint, OP_ArrayElemPtr, OP_ArrayElemMemberPtr, OP_ArrayElemFloat, #endif #ifdef GET_INTERP case OP_ArrayElemSint8: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemUint8: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemSint16: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemUint16: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemSint32: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemUint32: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemSint64: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemUint64: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemIntAP: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemIntAPS: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemBool: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemFixedPoint: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPtr: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemMemberPtr: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } case OP_ArrayElemFloat: { const auto V0 = ReadArg(S, PC); if (!ArrayElem(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ArrayElemSint8: Text.Op = PrintName("ArrayElemSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemUint8: Text.Op = PrintName("ArrayElemUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemSint16: Text.Op = PrintName("ArrayElemSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemUint16: Text.Op = PrintName("ArrayElemUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemSint32: Text.Op = PrintName("ArrayElemSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemUint32: Text.Op = PrintName("ArrayElemUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemSint64: Text.Op = PrintName("ArrayElemSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemUint64: Text.Op = PrintName("ArrayElemUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemIntAP: Text.Op = PrintName("ArrayElemIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemIntAPS: Text.Op = PrintName("ArrayElemIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemBool: Text.Op = PrintName("ArrayElemBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemFixedPoint: Text.Op = PrintName("ArrayElemFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPtr: Text.Op = PrintName("ArrayElemPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemMemberPtr: Text.Op = PrintName("ArrayElemMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemFloat: Text.Op = PrintName("ArrayElemFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitArrayElemSint8( uint32_t , const SourceInfo &); bool emitArrayElemUint8( uint32_t , const SourceInfo &); bool emitArrayElemSint16( uint32_t , const SourceInfo &); bool emitArrayElemUint16( uint32_t , const SourceInfo &); bool emitArrayElemSint32( uint32_t , const SourceInfo &); bool emitArrayElemUint32( uint32_t , const SourceInfo &); bool emitArrayElemSint64( uint32_t , const SourceInfo &); bool emitArrayElemUint64( uint32_t , const SourceInfo &); bool emitArrayElemIntAP( uint32_t , const SourceInfo &); bool emitArrayElemIntAPS( uint32_t , const SourceInfo &); bool emitArrayElemBool( uint32_t , const SourceInfo &); bool emitArrayElemFixedPoint( uint32_t , const SourceInfo &); bool emitArrayElemPtr( uint32_t , const SourceInfo &); bool emitArrayElemMemberPtr( uint32_t , const SourceInfo &); bool emitArrayElemFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitArrayElem(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitArrayElem(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitArrayElemSint8(A0, I); case PT_Uint8: return emitArrayElemUint8(A0, I); case PT_Sint16: return emitArrayElemSint16(A0, I); case PT_Uint16: return emitArrayElemUint16(A0, I); case PT_Sint32: return emitArrayElemSint32(A0, I); case PT_Uint32: return emitArrayElemUint32(A0, I); case PT_Sint64: return emitArrayElemSint64(A0, I); case PT_Uint64: return emitArrayElemUint64(A0, I); case PT_IntAP: return emitArrayElemIntAP(A0, I); case PT_IntAPS: return emitArrayElemIntAPS(A0, I); case PT_Bool: return emitArrayElemBool(A0, I); case PT_FixedPoint: return emitArrayElemFixedPoint(A0, I); case PT_Ptr: return emitArrayElemPtr(A0, I); case PT_MemberPtr: return emitArrayElemMemberPtr(A0, I); case PT_Float: return emitArrayElemFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitArrayElemSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemSint8, A0, L); } bool ByteCodeEmitter::emitArrayElemUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemUint8, A0, L); } bool ByteCodeEmitter::emitArrayElemSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemSint16, A0, L); } bool ByteCodeEmitter::emitArrayElemUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemUint16, A0, L); } bool ByteCodeEmitter::emitArrayElemSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemSint32, A0, L); } bool ByteCodeEmitter::emitArrayElemUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemUint32, A0, L); } bool ByteCodeEmitter::emitArrayElemSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemSint64, A0, L); } bool ByteCodeEmitter::emitArrayElemUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemUint64, A0, L); } bool ByteCodeEmitter::emitArrayElemIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemIntAP, A0, L); } bool ByteCodeEmitter::emitArrayElemIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemIntAPS, A0, L); } bool ByteCodeEmitter::emitArrayElemBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemBool, A0, L); } bool ByteCodeEmitter::emitArrayElemFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemFixedPoint, A0, L); } bool ByteCodeEmitter::emitArrayElemPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPtr, A0, L); } bool ByteCodeEmitter::emitArrayElemMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemMemberPtr, A0, L); } bool ByteCodeEmitter::emitArrayElemFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitArrayElemSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } bool EvalEmitter::emitArrayElemFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElem(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ArrayElemPopSint8, OP_ArrayElemPopUint8, OP_ArrayElemPopSint16, OP_ArrayElemPopUint16, OP_ArrayElemPopSint32, OP_ArrayElemPopUint32, OP_ArrayElemPopSint64, OP_ArrayElemPopUint64, OP_ArrayElemPopIntAP, OP_ArrayElemPopIntAPS, OP_ArrayElemPopBool, OP_ArrayElemPopFixedPoint, OP_ArrayElemPopPtr, OP_ArrayElemPopMemberPtr, OP_ArrayElemPopFloat, #endif #ifdef GET_INTERP case OP_ArrayElemPopSint8: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopUint8: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopSint16: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopUint16: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopSint32: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopUint32: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopSint64: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopUint64: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopIntAP: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopIntAPS: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopBool: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopFixedPoint: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopPtr: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopMemberPtr: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } case OP_ArrayElemPopFloat: { const auto V0 = ReadArg(S, PC); if (!ArrayElemPop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ArrayElemPopSint8: Text.Op = PrintName("ArrayElemPopSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopUint8: Text.Op = PrintName("ArrayElemPopUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopSint16: Text.Op = PrintName("ArrayElemPopSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopUint16: Text.Op = PrintName("ArrayElemPopUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopSint32: Text.Op = PrintName("ArrayElemPopSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopUint32: Text.Op = PrintName("ArrayElemPopUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopSint64: Text.Op = PrintName("ArrayElemPopSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopUint64: Text.Op = PrintName("ArrayElemPopUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopIntAP: Text.Op = PrintName("ArrayElemPopIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopIntAPS: Text.Op = PrintName("ArrayElemPopIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopBool: Text.Op = PrintName("ArrayElemPopBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopFixedPoint: Text.Op = PrintName("ArrayElemPopFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopPtr: Text.Op = PrintName("ArrayElemPopPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopMemberPtr: Text.Op = PrintName("ArrayElemPopMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_ArrayElemPopFloat: Text.Op = PrintName("ArrayElemPopFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitArrayElemPopSint8( uint32_t , const SourceInfo &); bool emitArrayElemPopUint8( uint32_t , const SourceInfo &); bool emitArrayElemPopSint16( uint32_t , const SourceInfo &); bool emitArrayElemPopUint16( uint32_t , const SourceInfo &); bool emitArrayElemPopSint32( uint32_t , const SourceInfo &); bool emitArrayElemPopUint32( uint32_t , const SourceInfo &); bool emitArrayElemPopSint64( uint32_t , const SourceInfo &); bool emitArrayElemPopUint64( uint32_t , const SourceInfo &); bool emitArrayElemPopIntAP( uint32_t , const SourceInfo &); bool emitArrayElemPopIntAPS( uint32_t , const SourceInfo &); bool emitArrayElemPopBool( uint32_t , const SourceInfo &); bool emitArrayElemPopFixedPoint( uint32_t , const SourceInfo &); bool emitArrayElemPopPtr( uint32_t , const SourceInfo &); bool emitArrayElemPopMemberPtr( uint32_t , const SourceInfo &); bool emitArrayElemPopFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitArrayElemPop(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitArrayElemPop(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitArrayElemPopSint8(A0, I); case PT_Uint8: return emitArrayElemPopUint8(A0, I); case PT_Sint16: return emitArrayElemPopSint16(A0, I); case PT_Uint16: return emitArrayElemPopUint16(A0, I); case PT_Sint32: return emitArrayElemPopSint32(A0, I); case PT_Uint32: return emitArrayElemPopUint32(A0, I); case PT_Sint64: return emitArrayElemPopSint64(A0, I); case PT_Uint64: return emitArrayElemPopUint64(A0, I); case PT_IntAP: return emitArrayElemPopIntAP(A0, I); case PT_IntAPS: return emitArrayElemPopIntAPS(A0, I); case PT_Bool: return emitArrayElemPopBool(A0, I); case PT_FixedPoint: return emitArrayElemPopFixedPoint(A0, I); case PT_Ptr: return emitArrayElemPopPtr(A0, I); case PT_MemberPtr: return emitArrayElemPopMemberPtr(A0, I); case PT_Float: return emitArrayElemPopFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitArrayElemPopSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopSint8, A0, L); } bool ByteCodeEmitter::emitArrayElemPopUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopUint8, A0, L); } bool ByteCodeEmitter::emitArrayElemPopSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopSint16, A0, L); } bool ByteCodeEmitter::emitArrayElemPopUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopUint16, A0, L); } bool ByteCodeEmitter::emitArrayElemPopSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopSint32, A0, L); } bool ByteCodeEmitter::emitArrayElemPopUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopUint32, A0, L); } bool ByteCodeEmitter::emitArrayElemPopSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopSint64, A0, L); } bool ByteCodeEmitter::emitArrayElemPopUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopUint64, A0, L); } bool ByteCodeEmitter::emitArrayElemPopIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopIntAP, A0, L); } bool ByteCodeEmitter::emitArrayElemPopIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopIntAPS, A0, L); } bool ByteCodeEmitter::emitArrayElemPopBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopBool, A0, L); } bool ByteCodeEmitter::emitArrayElemPopFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopFixedPoint, A0, L); } bool ByteCodeEmitter::emitArrayElemPopPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopPtr, A0, L); } bool ByteCodeEmitter::emitArrayElemPopMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopMemberPtr, A0, L); } bool ByteCodeEmitter::emitArrayElemPopFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ArrayElemPopFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitArrayElemPopSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } bool EvalEmitter::emitArrayElemPopFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ArrayElemPtrSint8, OP_ArrayElemPtrUint8, OP_ArrayElemPtrSint16, OP_ArrayElemPtrUint16, OP_ArrayElemPtrSint32, OP_ArrayElemPtrUint32, OP_ArrayElemPtrSint64, OP_ArrayElemPtrUint64, OP_ArrayElemPtrIntAP, OP_ArrayElemPtrIntAPS, OP_ArrayElemPtrBool, OP_ArrayElemPtrFixedPoint, #endif #ifdef GET_INTERP case OP_ArrayElemPtrSint8: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrUint8: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrSint16: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrUint16: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrSint32: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrUint32: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrSint64: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrUint64: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrIntAP: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrIntAPS: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrBool: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } case OP_ArrayElemPtrFixedPoint: { if (!ArrayElemPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_ArrayElemPtrSint8: Text.Op = PrintName("ArrayElemPtrSint8"); break; case OP_ArrayElemPtrUint8: Text.Op = PrintName("ArrayElemPtrUint8"); break; case OP_ArrayElemPtrSint16: Text.Op = PrintName("ArrayElemPtrSint16"); break; case OP_ArrayElemPtrUint16: Text.Op = PrintName("ArrayElemPtrUint16"); break; case OP_ArrayElemPtrSint32: Text.Op = PrintName("ArrayElemPtrSint32"); break; case OP_ArrayElemPtrUint32: Text.Op = PrintName("ArrayElemPtrUint32"); break; case OP_ArrayElemPtrSint64: Text.Op = PrintName("ArrayElemPtrSint64"); break; case OP_ArrayElemPtrUint64: Text.Op = PrintName("ArrayElemPtrUint64"); break; case OP_ArrayElemPtrIntAP: Text.Op = PrintName("ArrayElemPtrIntAP"); break; case OP_ArrayElemPtrIntAPS: Text.Op = PrintName("ArrayElemPtrIntAPS"); break; case OP_ArrayElemPtrBool: Text.Op = PrintName("ArrayElemPtrBool"); break; case OP_ArrayElemPtrFixedPoint: Text.Op = PrintName("ArrayElemPtrFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitArrayElemPtrSint8(const SourceInfo &); bool emitArrayElemPtrUint8(const SourceInfo &); bool emitArrayElemPtrSint16(const SourceInfo &); bool emitArrayElemPtrUint16(const SourceInfo &); bool emitArrayElemPtrSint32(const SourceInfo &); bool emitArrayElemPtrUint32(const SourceInfo &); bool emitArrayElemPtrSint64(const SourceInfo &); bool emitArrayElemPtrUint64(const SourceInfo &); bool emitArrayElemPtrIntAP(const SourceInfo &); bool emitArrayElemPtrIntAPS(const SourceInfo &); bool emitArrayElemPtrBool(const SourceInfo &); bool emitArrayElemPtrFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitArrayElemPtr(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitArrayElemPtr(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitArrayElemPtrSint8(I); case PT_Uint8: return emitArrayElemPtrUint8(I); case PT_Sint16: return emitArrayElemPtrSint16(I); case PT_Uint16: return emitArrayElemPtrUint16(I); case PT_Sint32: return emitArrayElemPtrSint32(I); case PT_Uint32: return emitArrayElemPtrUint32(I); case PT_Sint64: return emitArrayElemPtrSint64(I); case PT_Uint64: return emitArrayElemPtrUint64(I); case PT_IntAP: return emitArrayElemPtrIntAP(I); case PT_IntAPS: return emitArrayElemPtrIntAPS(I); case PT_Bool: return emitArrayElemPtrBool(I); case PT_FixedPoint: return emitArrayElemPtrFixedPoint(I); default: llvm_unreachable("invalid type: emitArrayElemPtr"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitArrayElemPtrSint8(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrSint8, L); } bool ByteCodeEmitter::emitArrayElemPtrUint8(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrUint8, L); } bool ByteCodeEmitter::emitArrayElemPtrSint16(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrSint16, L); } bool ByteCodeEmitter::emitArrayElemPtrUint16(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrUint16, L); } bool ByteCodeEmitter::emitArrayElemPtrSint32(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrSint32, L); } bool ByteCodeEmitter::emitArrayElemPtrUint32(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrUint32, L); } bool ByteCodeEmitter::emitArrayElemPtrSint64(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrSint64, L); } bool ByteCodeEmitter::emitArrayElemPtrUint64(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrUint64, L); } bool ByteCodeEmitter::emitArrayElemPtrIntAP(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrIntAP, L); } bool ByteCodeEmitter::emitArrayElemPtrIntAPS(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrIntAPS, L); } bool ByteCodeEmitter::emitArrayElemPtrBool(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrBool, L); } bool ByteCodeEmitter::emitArrayElemPtrFixedPoint(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitArrayElemPtrSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } bool EvalEmitter::emitArrayElemPtrFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_ArrayElemPtrPopSint8, OP_ArrayElemPtrPopUint8, OP_ArrayElemPtrPopSint16, OP_ArrayElemPtrPopUint16, OP_ArrayElemPtrPopSint32, OP_ArrayElemPtrPopUint32, OP_ArrayElemPtrPopSint64, OP_ArrayElemPtrPopUint64, OP_ArrayElemPtrPopIntAP, OP_ArrayElemPtrPopIntAPS, OP_ArrayElemPtrPopBool, OP_ArrayElemPtrPopFixedPoint, #endif #ifdef GET_INTERP case OP_ArrayElemPtrPopSint8: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopUint8: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopSint16: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopUint16: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopSint32: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopUint32: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopSint64: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopUint64: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopIntAP: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopIntAPS: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopBool: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } case OP_ArrayElemPtrPopFixedPoint: { if (!ArrayElemPtrPop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_ArrayElemPtrPopSint8: Text.Op = PrintName("ArrayElemPtrPopSint8"); break; case OP_ArrayElemPtrPopUint8: Text.Op = PrintName("ArrayElemPtrPopUint8"); break; case OP_ArrayElemPtrPopSint16: Text.Op = PrintName("ArrayElemPtrPopSint16"); break; case OP_ArrayElemPtrPopUint16: Text.Op = PrintName("ArrayElemPtrPopUint16"); break; case OP_ArrayElemPtrPopSint32: Text.Op = PrintName("ArrayElemPtrPopSint32"); break; case OP_ArrayElemPtrPopUint32: Text.Op = PrintName("ArrayElemPtrPopUint32"); break; case OP_ArrayElemPtrPopSint64: Text.Op = PrintName("ArrayElemPtrPopSint64"); break; case OP_ArrayElemPtrPopUint64: Text.Op = PrintName("ArrayElemPtrPopUint64"); break; case OP_ArrayElemPtrPopIntAP: Text.Op = PrintName("ArrayElemPtrPopIntAP"); break; case OP_ArrayElemPtrPopIntAPS: Text.Op = PrintName("ArrayElemPtrPopIntAPS"); break; case OP_ArrayElemPtrPopBool: Text.Op = PrintName("ArrayElemPtrPopBool"); break; case OP_ArrayElemPtrPopFixedPoint: Text.Op = PrintName("ArrayElemPtrPopFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitArrayElemPtrPopSint8(const SourceInfo &); bool emitArrayElemPtrPopUint8(const SourceInfo &); bool emitArrayElemPtrPopSint16(const SourceInfo &); bool emitArrayElemPtrPopUint16(const SourceInfo &); bool emitArrayElemPtrPopSint32(const SourceInfo &); bool emitArrayElemPtrPopUint32(const SourceInfo &); bool emitArrayElemPtrPopSint64(const SourceInfo &); bool emitArrayElemPtrPopUint64(const SourceInfo &); bool emitArrayElemPtrPopIntAP(const SourceInfo &); bool emitArrayElemPtrPopIntAPS(const SourceInfo &); bool emitArrayElemPtrPopBool(const SourceInfo &); bool emitArrayElemPtrPopFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitArrayElemPtrPop(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitArrayElemPtrPop(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitArrayElemPtrPopSint8(I); case PT_Uint8: return emitArrayElemPtrPopUint8(I); case PT_Sint16: return emitArrayElemPtrPopSint16(I); case PT_Uint16: return emitArrayElemPtrPopUint16(I); case PT_Sint32: return emitArrayElemPtrPopSint32(I); case PT_Uint32: return emitArrayElemPtrPopUint32(I); case PT_Sint64: return emitArrayElemPtrPopSint64(I); case PT_Uint64: return emitArrayElemPtrPopUint64(I); case PT_IntAP: return emitArrayElemPtrPopIntAP(I); case PT_IntAPS: return emitArrayElemPtrPopIntAPS(I); case PT_Bool: return emitArrayElemPtrPopBool(I); case PT_FixedPoint: return emitArrayElemPtrPopFixedPoint(I); default: llvm_unreachable("invalid type: emitArrayElemPtrPop"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitArrayElemPtrPopSint8(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopSint8, L); } bool ByteCodeEmitter::emitArrayElemPtrPopUint8(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopUint8, L); } bool ByteCodeEmitter::emitArrayElemPtrPopSint16(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopSint16, L); } bool ByteCodeEmitter::emitArrayElemPtrPopUint16(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopUint16, L); } bool ByteCodeEmitter::emitArrayElemPtrPopSint32(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopSint32, L); } bool ByteCodeEmitter::emitArrayElemPtrPopUint32(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopUint32, L); } bool ByteCodeEmitter::emitArrayElemPtrPopSint64(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopSint64, L); } bool ByteCodeEmitter::emitArrayElemPtrPopUint64(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopUint64, L); } bool ByteCodeEmitter::emitArrayElemPtrPopIntAP(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopIntAP, L); } bool ByteCodeEmitter::emitArrayElemPtrPopIntAPS(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopIntAPS, L); } bool ByteCodeEmitter::emitArrayElemPtrPopBool(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopBool, L); } bool ByteCodeEmitter::emitArrayElemPtrPopFixedPoint(const SourceInfo &L) { return emitOp<>(OP_ArrayElemPtrPopFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitArrayElemPtrPopSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } bool EvalEmitter::emitArrayElemPtrPopFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ArrayElemPtrPop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Assume, #endif #ifdef GET_INTERP case OP_Assume: { if (!Assume(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_Assume: Text.Op = PrintName("Assume"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitAssume(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitAssume(const SourceInfo &L) { return emitOp<>(OP_Assume, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitAssume(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Assume(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_BCP, #endif #ifdef GET_INTERP case OP_BCP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!BCP(S, PC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_BCP: Text.Op = PrintName("BCP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitBCP( int32_t , PrimType , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitBCP( int32_t A0, PrimType A1, const SourceInfo &L) { return emitOp(OP_BCP, A0, A1, L); } #endif #ifdef GET_OPCODE_NAMES OP_BitAndSint8, OP_BitAndUint8, OP_BitAndSint16, OP_BitAndUint16, OP_BitAndSint32, OP_BitAndUint32, OP_BitAndSint64, OP_BitAndUint64, OP_BitAndIntAP, OP_BitAndIntAPS, OP_BitAndFixedPoint, #endif #ifdef GET_INTERP case OP_BitAndSint8: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndUint8: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndSint16: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndUint16: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndSint32: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndUint32: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndSint64: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndUint64: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndIntAP: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndIntAPS: { if (!BitAnd(S, OpPC)) return false; continue; } case OP_BitAndFixedPoint: { if (!BitAnd(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_BitAndSint8: Text.Op = PrintName("BitAndSint8"); break; case OP_BitAndUint8: Text.Op = PrintName("BitAndUint8"); break; case OP_BitAndSint16: Text.Op = PrintName("BitAndSint16"); break; case OP_BitAndUint16: Text.Op = PrintName("BitAndUint16"); break; case OP_BitAndSint32: Text.Op = PrintName("BitAndSint32"); break; case OP_BitAndUint32: Text.Op = PrintName("BitAndUint32"); break; case OP_BitAndSint64: Text.Op = PrintName("BitAndSint64"); break; case OP_BitAndUint64: Text.Op = PrintName("BitAndUint64"); break; case OP_BitAndIntAP: Text.Op = PrintName("BitAndIntAP"); break; case OP_BitAndIntAPS: Text.Op = PrintName("BitAndIntAPS"); break; case OP_BitAndFixedPoint: Text.Op = PrintName("BitAndFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitBitAndSint8(const SourceInfo &); bool emitBitAndUint8(const SourceInfo &); bool emitBitAndSint16(const SourceInfo &); bool emitBitAndUint16(const SourceInfo &); bool emitBitAndSint32(const SourceInfo &); bool emitBitAndUint32(const SourceInfo &); bool emitBitAndSint64(const SourceInfo &); bool emitBitAndUint64(const SourceInfo &); bool emitBitAndIntAP(const SourceInfo &); bool emitBitAndIntAPS(const SourceInfo &); bool emitBitAndFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitBitAnd(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitBitAnd(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitBitAndSint8(I); case PT_Uint8: return emitBitAndUint8(I); case PT_Sint16: return emitBitAndSint16(I); case PT_Uint16: return emitBitAndUint16(I); case PT_Sint32: return emitBitAndSint32(I); case PT_Uint32: return emitBitAndUint32(I); case PT_Sint64: return emitBitAndSint64(I); case PT_Uint64: return emitBitAndUint64(I); case PT_IntAP: return emitBitAndIntAP(I); case PT_IntAPS: return emitBitAndIntAPS(I); case PT_FixedPoint: return emitBitAndFixedPoint(I); default: llvm_unreachable("invalid type: emitBitAnd"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitBitAndSint8(const SourceInfo &L) { return emitOp<>(OP_BitAndSint8, L); } bool ByteCodeEmitter::emitBitAndUint8(const SourceInfo &L) { return emitOp<>(OP_BitAndUint8, L); } bool ByteCodeEmitter::emitBitAndSint16(const SourceInfo &L) { return emitOp<>(OP_BitAndSint16, L); } bool ByteCodeEmitter::emitBitAndUint16(const SourceInfo &L) { return emitOp<>(OP_BitAndUint16, L); } bool ByteCodeEmitter::emitBitAndSint32(const SourceInfo &L) { return emitOp<>(OP_BitAndSint32, L); } bool ByteCodeEmitter::emitBitAndUint32(const SourceInfo &L) { return emitOp<>(OP_BitAndUint32, L); } bool ByteCodeEmitter::emitBitAndSint64(const SourceInfo &L) { return emitOp<>(OP_BitAndSint64, L); } bool ByteCodeEmitter::emitBitAndUint64(const SourceInfo &L) { return emitOp<>(OP_BitAndUint64, L); } bool ByteCodeEmitter::emitBitAndIntAP(const SourceInfo &L) { return emitOp<>(OP_BitAndIntAP, L); } bool ByteCodeEmitter::emitBitAndIntAPS(const SourceInfo &L) { return emitOp<>(OP_BitAndIntAPS, L); } bool ByteCodeEmitter::emitBitAndFixedPoint(const SourceInfo &L) { return emitOp<>(OP_BitAndFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitBitAndSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } bool EvalEmitter::emitBitAndFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitAnd(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_BitCast, #endif #ifdef GET_INTERP case OP_BitCast: { if (!BitCast(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_BitCast: Text.Op = PrintName("BitCast"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitBitCast(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitBitCast(const SourceInfo &L) { return emitOp<>(OP_BitCast, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitBitCast(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCast(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_BitCastPrimUint8, OP_BitCastPrimSint8, OP_BitCastPrimUint16, OP_BitCastPrimSint16, OP_BitCastPrimUint32, OP_BitCastPrimSint32, OP_BitCastPrimUint64, OP_BitCastPrimSint64, OP_BitCastPrimIntAP, OP_BitCastPrimIntAPS, OP_BitCastPrimBool, OP_BitCastPrimFloat, OP_BitCastPrimPtr, #endif #ifdef GET_INTERP case OP_BitCastPrimUint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimSint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimUint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimSint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimUint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimSint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimUint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimSint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimIntAP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimIntAPS: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimBool: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimFloat: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } case OP_BitCastPrimPtr: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!BitCastPrim(S, OpPC, V0, V1, V2)) return false; continue; } #endif #ifdef GET_DISASM case OP_BitCastPrimUint8: Text.Op = PrintName("BitCastPrimUint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimSint8: Text.Op = PrintName("BitCastPrimSint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimUint16: Text.Op = PrintName("BitCastPrimUint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimSint16: Text.Op = PrintName("BitCastPrimSint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimUint32: Text.Op = PrintName("BitCastPrimUint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimSint32: Text.Op = PrintName("BitCastPrimSint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimUint64: Text.Op = PrintName("BitCastPrimUint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimSint64: Text.Op = PrintName("BitCastPrimSint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimIntAP: Text.Op = PrintName("BitCastPrimIntAP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimIntAPS: Text.Op = PrintName("BitCastPrimIntAPS"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimBool: Text.Op = PrintName("BitCastPrimBool"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimFloat: Text.Op = PrintName("BitCastPrimFloat"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_BitCastPrimPtr: Text.Op = PrintName("BitCastPrimPtr"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitBitCastPrimUint8( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimSint8( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimUint16( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimSint16( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimUint32( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimSint32( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimUint64( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimSint64( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimIntAP( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimIntAPS( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimBool( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimFloat( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); bool emitBitCastPrimPtr( bool , uint32_t , const llvm::fltSemantics * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitBitCastPrim(PrimType, bool, uint32_t, const llvm::fltSemantics *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitBitCastPrim(PrimType T0, bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &I) { switch (T0) { case PT_Uint8: return emitBitCastPrimUint8(A0, A1, A2, I); case PT_Sint8: return emitBitCastPrimSint8(A0, A1, A2, I); case PT_Uint16: return emitBitCastPrimUint16(A0, A1, A2, I); case PT_Sint16: return emitBitCastPrimSint16(A0, A1, A2, I); case PT_Uint32: return emitBitCastPrimUint32(A0, A1, A2, I); case PT_Sint32: return emitBitCastPrimSint32(A0, A1, A2, I); case PT_Uint64: return emitBitCastPrimUint64(A0, A1, A2, I); case PT_Sint64: return emitBitCastPrimSint64(A0, A1, A2, I); case PT_IntAP: return emitBitCastPrimIntAP(A0, A1, A2, I); case PT_IntAPS: return emitBitCastPrimIntAPS(A0, A1, A2, I); case PT_Bool: return emitBitCastPrimBool(A0, A1, A2, I); case PT_Float: return emitBitCastPrimFloat(A0, A1, A2, I); case PT_Ptr: return emitBitCastPrimPtr(A0, A1, A2, I); default: llvm_unreachable("invalid type: emitBitCastPrim"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitBitCastPrimUint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimUint8, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimSint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimSint8, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimUint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimUint16, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimSint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimSint16, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimUint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimUint32, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimSint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimSint32, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimUint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimUint64, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimSint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimSint64, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimIntAP( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimIntAP, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimIntAPS( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimIntAPS, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimBool( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimBool, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimFloat( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimFloat, A0, A1, A2, L); } bool ByteCodeEmitter::emitBitCastPrimPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { return emitOp(OP_BitCastPrimPtr, A0, A1, A2, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitBitCastPrimUint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimSint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimUint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimSint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimUint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimSint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimUint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimSint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimIntAP( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimIntAPS( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimBool( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimFloat( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitBitCastPrimPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitCastPrim(S, OpPC, A0, A1, A2); } #endif #ifdef GET_OPCODE_NAMES OP_BitOrSint8, OP_BitOrUint8, OP_BitOrSint16, OP_BitOrUint16, OP_BitOrSint32, OP_BitOrUint32, OP_BitOrSint64, OP_BitOrUint64, OP_BitOrIntAP, OP_BitOrIntAPS, OP_BitOrFixedPoint, #endif #ifdef GET_INTERP case OP_BitOrSint8: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrUint8: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrSint16: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrUint16: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrSint32: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrUint32: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrSint64: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrUint64: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrIntAP: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrIntAPS: { if (!BitOr(S, OpPC)) return false; continue; } case OP_BitOrFixedPoint: { if (!BitOr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_BitOrSint8: Text.Op = PrintName("BitOrSint8"); break; case OP_BitOrUint8: Text.Op = PrintName("BitOrUint8"); break; case OP_BitOrSint16: Text.Op = PrintName("BitOrSint16"); break; case OP_BitOrUint16: Text.Op = PrintName("BitOrUint16"); break; case OP_BitOrSint32: Text.Op = PrintName("BitOrSint32"); break; case OP_BitOrUint32: Text.Op = PrintName("BitOrUint32"); break; case OP_BitOrSint64: Text.Op = PrintName("BitOrSint64"); break; case OP_BitOrUint64: Text.Op = PrintName("BitOrUint64"); break; case OP_BitOrIntAP: Text.Op = PrintName("BitOrIntAP"); break; case OP_BitOrIntAPS: Text.Op = PrintName("BitOrIntAPS"); break; case OP_BitOrFixedPoint: Text.Op = PrintName("BitOrFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitBitOrSint8(const SourceInfo &); bool emitBitOrUint8(const SourceInfo &); bool emitBitOrSint16(const SourceInfo &); bool emitBitOrUint16(const SourceInfo &); bool emitBitOrSint32(const SourceInfo &); bool emitBitOrUint32(const SourceInfo &); bool emitBitOrSint64(const SourceInfo &); bool emitBitOrUint64(const SourceInfo &); bool emitBitOrIntAP(const SourceInfo &); bool emitBitOrIntAPS(const SourceInfo &); bool emitBitOrFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitBitOr(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitBitOr(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitBitOrSint8(I); case PT_Uint8: return emitBitOrUint8(I); case PT_Sint16: return emitBitOrSint16(I); case PT_Uint16: return emitBitOrUint16(I); case PT_Sint32: return emitBitOrSint32(I); case PT_Uint32: return emitBitOrUint32(I); case PT_Sint64: return emitBitOrSint64(I); case PT_Uint64: return emitBitOrUint64(I); case PT_IntAP: return emitBitOrIntAP(I); case PT_IntAPS: return emitBitOrIntAPS(I); case PT_FixedPoint: return emitBitOrFixedPoint(I); default: llvm_unreachable("invalid type: emitBitOr"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitBitOrSint8(const SourceInfo &L) { return emitOp<>(OP_BitOrSint8, L); } bool ByteCodeEmitter::emitBitOrUint8(const SourceInfo &L) { return emitOp<>(OP_BitOrUint8, L); } bool ByteCodeEmitter::emitBitOrSint16(const SourceInfo &L) { return emitOp<>(OP_BitOrSint16, L); } bool ByteCodeEmitter::emitBitOrUint16(const SourceInfo &L) { return emitOp<>(OP_BitOrUint16, L); } bool ByteCodeEmitter::emitBitOrSint32(const SourceInfo &L) { return emitOp<>(OP_BitOrSint32, L); } bool ByteCodeEmitter::emitBitOrUint32(const SourceInfo &L) { return emitOp<>(OP_BitOrUint32, L); } bool ByteCodeEmitter::emitBitOrSint64(const SourceInfo &L) { return emitOp<>(OP_BitOrSint64, L); } bool ByteCodeEmitter::emitBitOrUint64(const SourceInfo &L) { return emitOp<>(OP_BitOrUint64, L); } bool ByteCodeEmitter::emitBitOrIntAP(const SourceInfo &L) { return emitOp<>(OP_BitOrIntAP, L); } bool ByteCodeEmitter::emitBitOrIntAPS(const SourceInfo &L) { return emitOp<>(OP_BitOrIntAPS, L); } bool ByteCodeEmitter::emitBitOrFixedPoint(const SourceInfo &L) { return emitOp<>(OP_BitOrFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitBitOrSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } bool EvalEmitter::emitBitOrFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitOr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_BitXorSint8, OP_BitXorUint8, OP_BitXorSint16, OP_BitXorUint16, OP_BitXorSint32, OP_BitXorUint32, OP_BitXorSint64, OP_BitXorUint64, OP_BitXorIntAP, OP_BitXorIntAPS, OP_BitXorFixedPoint, #endif #ifdef GET_INTERP case OP_BitXorSint8: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorUint8: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorSint16: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorUint16: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorSint32: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorUint32: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorSint64: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorUint64: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorIntAP: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorIntAPS: { if (!BitXor(S, OpPC)) return false; continue; } case OP_BitXorFixedPoint: { if (!BitXor(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_BitXorSint8: Text.Op = PrintName("BitXorSint8"); break; case OP_BitXorUint8: Text.Op = PrintName("BitXorUint8"); break; case OP_BitXorSint16: Text.Op = PrintName("BitXorSint16"); break; case OP_BitXorUint16: Text.Op = PrintName("BitXorUint16"); break; case OP_BitXorSint32: Text.Op = PrintName("BitXorSint32"); break; case OP_BitXorUint32: Text.Op = PrintName("BitXorUint32"); break; case OP_BitXorSint64: Text.Op = PrintName("BitXorSint64"); break; case OP_BitXorUint64: Text.Op = PrintName("BitXorUint64"); break; case OP_BitXorIntAP: Text.Op = PrintName("BitXorIntAP"); break; case OP_BitXorIntAPS: Text.Op = PrintName("BitXorIntAPS"); break; case OP_BitXorFixedPoint: Text.Op = PrintName("BitXorFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitBitXorSint8(const SourceInfo &); bool emitBitXorUint8(const SourceInfo &); bool emitBitXorSint16(const SourceInfo &); bool emitBitXorUint16(const SourceInfo &); bool emitBitXorSint32(const SourceInfo &); bool emitBitXorUint32(const SourceInfo &); bool emitBitXorSint64(const SourceInfo &); bool emitBitXorUint64(const SourceInfo &); bool emitBitXorIntAP(const SourceInfo &); bool emitBitXorIntAPS(const SourceInfo &); bool emitBitXorFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitBitXor(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitBitXor(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitBitXorSint8(I); case PT_Uint8: return emitBitXorUint8(I); case PT_Sint16: return emitBitXorSint16(I); case PT_Uint16: return emitBitXorUint16(I); case PT_Sint32: return emitBitXorSint32(I); case PT_Uint32: return emitBitXorUint32(I); case PT_Sint64: return emitBitXorSint64(I); case PT_Uint64: return emitBitXorUint64(I); case PT_IntAP: return emitBitXorIntAP(I); case PT_IntAPS: return emitBitXorIntAPS(I); case PT_FixedPoint: return emitBitXorFixedPoint(I); default: llvm_unreachable("invalid type: emitBitXor"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitBitXorSint8(const SourceInfo &L) { return emitOp<>(OP_BitXorSint8, L); } bool ByteCodeEmitter::emitBitXorUint8(const SourceInfo &L) { return emitOp<>(OP_BitXorUint8, L); } bool ByteCodeEmitter::emitBitXorSint16(const SourceInfo &L) { return emitOp<>(OP_BitXorSint16, L); } bool ByteCodeEmitter::emitBitXorUint16(const SourceInfo &L) { return emitOp<>(OP_BitXorUint16, L); } bool ByteCodeEmitter::emitBitXorSint32(const SourceInfo &L) { return emitOp<>(OP_BitXorSint32, L); } bool ByteCodeEmitter::emitBitXorUint32(const SourceInfo &L) { return emitOp<>(OP_BitXorUint32, L); } bool ByteCodeEmitter::emitBitXorSint64(const SourceInfo &L) { return emitOp<>(OP_BitXorSint64, L); } bool ByteCodeEmitter::emitBitXorUint64(const SourceInfo &L) { return emitOp<>(OP_BitXorUint64, L); } bool ByteCodeEmitter::emitBitXorIntAP(const SourceInfo &L) { return emitOp<>(OP_BitXorIntAP, L); } bool ByteCodeEmitter::emitBitXorIntAPS(const SourceInfo &L) { return emitOp<>(OP_BitXorIntAPS, L); } bool ByteCodeEmitter::emitBitXorFixedPoint(const SourceInfo &L) { return emitOp<>(OP_BitXorFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitBitXorSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } bool EvalEmitter::emitBitXorFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return BitXor(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CMP3Sint8, OP_CMP3Uint8, OP_CMP3Sint16, OP_CMP3Uint16, OP_CMP3Sint32, OP_CMP3Uint32, OP_CMP3Sint64, OP_CMP3Uint64, OP_CMP3IntAP, OP_CMP3IntAPS, OP_CMP3Bool, OP_CMP3FixedPoint, OP_CMP3Ptr, OP_CMP3Float, #endif #ifdef GET_INTERP case OP_CMP3Sint8: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Uint8: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Sint16: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Uint16: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Sint32: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Uint32: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Sint64: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Uint64: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3IntAP: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3IntAPS: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Bool: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3FixedPoint: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Ptr: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } case OP_CMP3Float: { const auto V0 = ReadArg(S, PC); if (!CMP3(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CMP3Sint8: Text.Op = PrintName("CMP3Sint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Uint8: Text.Op = PrintName("CMP3Uint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Sint16: Text.Op = PrintName("CMP3Sint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Uint16: Text.Op = PrintName("CMP3Uint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Sint32: Text.Op = PrintName("CMP3Sint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Uint32: Text.Op = PrintName("CMP3Uint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Sint64: Text.Op = PrintName("CMP3Sint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Uint64: Text.Op = PrintName("CMP3Uint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3IntAP: Text.Op = PrintName("CMP3IntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3IntAPS: Text.Op = PrintName("CMP3IntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Bool: Text.Op = PrintName("CMP3Bool"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3FixedPoint: Text.Op = PrintName("CMP3FixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Ptr: Text.Op = PrintName("CMP3Ptr"); Text.Args.push_back(printArg(P, PC)); break; case OP_CMP3Float: Text.Op = PrintName("CMP3Float"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCMP3Sint8( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Uint8( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Sint16( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Uint16( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Sint32( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Uint32( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Sint64( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Uint64( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3IntAP( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3IntAPS( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Bool( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3FixedPoint( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Ptr( const ComparisonCategoryInfo * , const SourceInfo &); bool emitCMP3Float( const ComparisonCategoryInfo * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCMP3(PrimType, const ComparisonCategoryInfo *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCMP3(PrimType T0, const ComparisonCategoryInfo * A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCMP3Sint8(A0, I); case PT_Uint8: return emitCMP3Uint8(A0, I); case PT_Sint16: return emitCMP3Sint16(A0, I); case PT_Uint16: return emitCMP3Uint16(A0, I); case PT_Sint32: return emitCMP3Sint32(A0, I); case PT_Uint32: return emitCMP3Uint32(A0, I); case PT_Sint64: return emitCMP3Sint64(A0, I); case PT_Uint64: return emitCMP3Uint64(A0, I); case PT_IntAP: return emitCMP3IntAP(A0, I); case PT_IntAPS: return emitCMP3IntAPS(A0, I); case PT_Bool: return emitCMP3Bool(A0, I); case PT_FixedPoint: return emitCMP3FixedPoint(A0, I); case PT_Ptr: return emitCMP3Ptr(A0, I); case PT_Float: return emitCMP3Float(A0, I); default: llvm_unreachable("invalid type: emitCMP3"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCMP3Sint8( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Sint8, A0, L); } bool ByteCodeEmitter::emitCMP3Uint8( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Uint8, A0, L); } bool ByteCodeEmitter::emitCMP3Sint16( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Sint16, A0, L); } bool ByteCodeEmitter::emitCMP3Uint16( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Uint16, A0, L); } bool ByteCodeEmitter::emitCMP3Sint32( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Sint32, A0, L); } bool ByteCodeEmitter::emitCMP3Uint32( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Uint32, A0, L); } bool ByteCodeEmitter::emitCMP3Sint64( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Sint64, A0, L); } bool ByteCodeEmitter::emitCMP3Uint64( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Uint64, A0, L); } bool ByteCodeEmitter::emitCMP3IntAP( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3IntAP, A0, L); } bool ByteCodeEmitter::emitCMP3IntAPS( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3IntAPS, A0, L); } bool ByteCodeEmitter::emitCMP3Bool( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Bool, A0, L); } bool ByteCodeEmitter::emitCMP3FixedPoint( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3FixedPoint, A0, L); } bool ByteCodeEmitter::emitCMP3Ptr( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Ptr, A0, L); } bool ByteCodeEmitter::emitCMP3Float( const ComparisonCategoryInfo * A0, const SourceInfo &L) { return emitOp(OP_CMP3Float, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCMP3Sint8( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Uint8( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Sint16( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Uint16( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Sint32( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Uint32( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Sint64( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Uint64( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3IntAP( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3IntAPS( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Bool( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3FixedPoint( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Ptr( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } bool EvalEmitter::emitCMP3Float( const ComparisonCategoryInfo * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CMP3(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_Call, #endif #ifdef GET_INTERP case OP_Call: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!Call(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_Call: Text.Op = PrintName("Call"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCall( const Function * , uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCall( const Function * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_Call, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCall( const Function * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Call(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_CallBI, #endif #ifdef GET_INTERP case OP_CallBI: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CallBI(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_CallBI: Text.Op = PrintName("CallBI"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCallBI( const CallExpr * , uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCallBI( const CallExpr * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CallBI, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCallBI( const CallExpr * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CallBI(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_CallPtr, #endif #ifdef GET_INTERP case OP_CallPtr: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CallPtr(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_CallPtr: Text.Op = PrintName("CallPtr"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCallPtr( uint32_t , const CallExpr * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCallPtr( uint32_t A0, const CallExpr * A1, const SourceInfo &L) { return emitOp(OP_CallPtr, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCallPtr( uint32_t A0, const CallExpr * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CallPtr(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_CallVar, #endif #ifdef GET_INTERP case OP_CallVar: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CallVar(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_CallVar: Text.Op = PrintName("CallVar"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCallVar( const Function * , uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCallVar( const Function * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CallVar, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCallVar( const Function * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CallVar(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_CallVirt, #endif #ifdef GET_INTERP case OP_CallVirt: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CallVirt(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_CallVirt: Text.Op = PrintName("CallVirt"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCallVirt( const Function * , uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCallVirt( const Function * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CallVirt, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCallVirt( const Function * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CallVirt(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_CastUint8Uint8, OP_CastUint8Sint8, OP_CastUint8Uint16, OP_CastUint8Sint16, OP_CastUint8Uint32, OP_CastUint8Sint32, OP_CastUint8Uint64, OP_CastUint8Sint64, OP_CastUint8Bool, OP_CastSint8Uint8, OP_CastSint8Sint8, OP_CastSint8Uint16, OP_CastSint8Sint16, OP_CastSint8Uint32, OP_CastSint8Sint32, OP_CastSint8Uint64, OP_CastSint8Sint64, OP_CastSint8Bool, OP_CastUint16Uint8, OP_CastUint16Sint8, OP_CastUint16Uint16, OP_CastUint16Sint16, OP_CastUint16Uint32, OP_CastUint16Sint32, OP_CastUint16Uint64, OP_CastUint16Sint64, OP_CastUint16Bool, OP_CastSint16Uint8, OP_CastSint16Sint8, OP_CastSint16Uint16, OP_CastSint16Sint16, OP_CastSint16Uint32, OP_CastSint16Sint32, OP_CastSint16Uint64, OP_CastSint16Sint64, OP_CastSint16Bool, OP_CastUint32Uint8, OP_CastUint32Sint8, OP_CastUint32Uint16, OP_CastUint32Sint16, OP_CastUint32Uint32, OP_CastUint32Sint32, OP_CastUint32Uint64, OP_CastUint32Sint64, OP_CastUint32Bool, OP_CastSint32Uint8, OP_CastSint32Sint8, OP_CastSint32Uint16, OP_CastSint32Sint16, OP_CastSint32Uint32, OP_CastSint32Sint32, OP_CastSint32Uint64, OP_CastSint32Sint64, OP_CastSint32Bool, OP_CastUint64Uint8, OP_CastUint64Sint8, OP_CastUint64Uint16, OP_CastUint64Sint16, OP_CastUint64Uint32, OP_CastUint64Sint32, OP_CastUint64Uint64, OP_CastUint64Sint64, OP_CastUint64Bool, OP_CastSint64Uint8, OP_CastSint64Sint8, OP_CastSint64Uint16, OP_CastSint64Sint16, OP_CastSint64Uint32, OP_CastSint64Sint32, OP_CastSint64Uint64, OP_CastSint64Sint64, OP_CastSint64Bool, OP_CastBoolUint8, OP_CastBoolSint8, OP_CastBoolUint16, OP_CastBoolSint16, OP_CastBoolUint32, OP_CastBoolSint32, OP_CastBoolUint64, OP_CastBoolSint64, OP_CastBoolBool, OP_CastIntAPUint8, OP_CastIntAPSint8, OP_CastIntAPUint16, OP_CastIntAPSint16, OP_CastIntAPUint32, OP_CastIntAPSint32, OP_CastIntAPUint64, OP_CastIntAPSint64, OP_CastIntAPBool, OP_CastIntAPSUint8, OP_CastIntAPSSint8, OP_CastIntAPSUint16, OP_CastIntAPSSint16, OP_CastIntAPSUint32, OP_CastIntAPSSint32, OP_CastIntAPSUint64, OP_CastIntAPSSint64, OP_CastIntAPSBool, OP_CastFixedPointUint8, OP_CastFixedPointSint8, OP_CastFixedPointUint16, OP_CastFixedPointSint16, OP_CastFixedPointUint32, OP_CastFixedPointSint32, OP_CastFixedPointUint64, OP_CastFixedPointSint64, OP_CastFixedPointBool, #endif #ifdef GET_INTERP case OP_CastUint8Uint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint8Sint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint8Uint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint8Sint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint8Uint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint8Sint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint8Uint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint8Sint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint8Bool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint8Uint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint8Sint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint8Uint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint8Sint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint8Uint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint8Sint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint8Uint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint8Sint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint8Bool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint16Uint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint16Sint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint16Uint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint16Sint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint16Uint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint16Sint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint16Uint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint16Sint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint16Bool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint16Uint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint16Sint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint16Uint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint16Sint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint16Uint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint16Sint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint16Uint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint16Sint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint16Bool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint32Uint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint32Sint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint32Uint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint32Sint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint32Uint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint32Sint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint32Uint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint32Sint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint32Bool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint32Uint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint32Sint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint32Uint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint32Sint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint32Uint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint32Sint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint32Uint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint32Sint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint32Bool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint64Uint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint64Sint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint64Uint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint64Sint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint64Uint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint64Sint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint64Uint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint64Sint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastUint64Bool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint64Uint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint64Sint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint64Uint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint64Sint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint64Uint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint64Sint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint64Uint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint64Sint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastSint64Bool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastBoolUint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastBoolSint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastBoolUint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastBoolSint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastBoolUint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastBoolSint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastBoolUint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastBoolSint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastBoolBool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPUint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPUint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPUint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPUint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPBool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSUint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSSint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSUint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSSint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSUint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSSint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSUint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSSint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastIntAPSBool: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastFixedPointUint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastFixedPointSint8: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastFixedPointUint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastFixedPointSint16: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastFixedPointUint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastFixedPointSint32: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastFixedPointUint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastFixedPointSint64: { if (!Cast(S, OpPC)) return false; continue; } case OP_CastFixedPointBool: { if (!Cast(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastUint8Uint8: Text.Op = PrintName("CastUint8Uint8"); break; case OP_CastUint8Sint8: Text.Op = PrintName("CastUint8Sint8"); break; case OP_CastUint8Uint16: Text.Op = PrintName("CastUint8Uint16"); break; case OP_CastUint8Sint16: Text.Op = PrintName("CastUint8Sint16"); break; case OP_CastUint8Uint32: Text.Op = PrintName("CastUint8Uint32"); break; case OP_CastUint8Sint32: Text.Op = PrintName("CastUint8Sint32"); break; case OP_CastUint8Uint64: Text.Op = PrintName("CastUint8Uint64"); break; case OP_CastUint8Sint64: Text.Op = PrintName("CastUint8Sint64"); break; case OP_CastUint8Bool: Text.Op = PrintName("CastUint8Bool"); break; case OP_CastSint8Uint8: Text.Op = PrintName("CastSint8Uint8"); break; case OP_CastSint8Sint8: Text.Op = PrintName("CastSint8Sint8"); break; case OP_CastSint8Uint16: Text.Op = PrintName("CastSint8Uint16"); break; case OP_CastSint8Sint16: Text.Op = PrintName("CastSint8Sint16"); break; case OP_CastSint8Uint32: Text.Op = PrintName("CastSint8Uint32"); break; case OP_CastSint8Sint32: Text.Op = PrintName("CastSint8Sint32"); break; case OP_CastSint8Uint64: Text.Op = PrintName("CastSint8Uint64"); break; case OP_CastSint8Sint64: Text.Op = PrintName("CastSint8Sint64"); break; case OP_CastSint8Bool: Text.Op = PrintName("CastSint8Bool"); break; case OP_CastUint16Uint8: Text.Op = PrintName("CastUint16Uint8"); break; case OP_CastUint16Sint8: Text.Op = PrintName("CastUint16Sint8"); break; case OP_CastUint16Uint16: Text.Op = PrintName("CastUint16Uint16"); break; case OP_CastUint16Sint16: Text.Op = PrintName("CastUint16Sint16"); break; case OP_CastUint16Uint32: Text.Op = PrintName("CastUint16Uint32"); break; case OP_CastUint16Sint32: Text.Op = PrintName("CastUint16Sint32"); break; case OP_CastUint16Uint64: Text.Op = PrintName("CastUint16Uint64"); break; case OP_CastUint16Sint64: Text.Op = PrintName("CastUint16Sint64"); break; case OP_CastUint16Bool: Text.Op = PrintName("CastUint16Bool"); break; case OP_CastSint16Uint8: Text.Op = PrintName("CastSint16Uint8"); break; case OP_CastSint16Sint8: Text.Op = PrintName("CastSint16Sint8"); break; case OP_CastSint16Uint16: Text.Op = PrintName("CastSint16Uint16"); break; case OP_CastSint16Sint16: Text.Op = PrintName("CastSint16Sint16"); break; case OP_CastSint16Uint32: Text.Op = PrintName("CastSint16Uint32"); break; case OP_CastSint16Sint32: Text.Op = PrintName("CastSint16Sint32"); break; case OP_CastSint16Uint64: Text.Op = PrintName("CastSint16Uint64"); break; case OP_CastSint16Sint64: Text.Op = PrintName("CastSint16Sint64"); break; case OP_CastSint16Bool: Text.Op = PrintName("CastSint16Bool"); break; case OP_CastUint32Uint8: Text.Op = PrintName("CastUint32Uint8"); break; case OP_CastUint32Sint8: Text.Op = PrintName("CastUint32Sint8"); break; case OP_CastUint32Uint16: Text.Op = PrintName("CastUint32Uint16"); break; case OP_CastUint32Sint16: Text.Op = PrintName("CastUint32Sint16"); break; case OP_CastUint32Uint32: Text.Op = PrintName("CastUint32Uint32"); break; case OP_CastUint32Sint32: Text.Op = PrintName("CastUint32Sint32"); break; case OP_CastUint32Uint64: Text.Op = PrintName("CastUint32Uint64"); break; case OP_CastUint32Sint64: Text.Op = PrintName("CastUint32Sint64"); break; case OP_CastUint32Bool: Text.Op = PrintName("CastUint32Bool"); break; case OP_CastSint32Uint8: Text.Op = PrintName("CastSint32Uint8"); break; case OP_CastSint32Sint8: Text.Op = PrintName("CastSint32Sint8"); break; case OP_CastSint32Uint16: Text.Op = PrintName("CastSint32Uint16"); break; case OP_CastSint32Sint16: Text.Op = PrintName("CastSint32Sint16"); break; case OP_CastSint32Uint32: Text.Op = PrintName("CastSint32Uint32"); break; case OP_CastSint32Sint32: Text.Op = PrintName("CastSint32Sint32"); break; case OP_CastSint32Uint64: Text.Op = PrintName("CastSint32Uint64"); break; case OP_CastSint32Sint64: Text.Op = PrintName("CastSint32Sint64"); break; case OP_CastSint32Bool: Text.Op = PrintName("CastSint32Bool"); break; case OP_CastUint64Uint8: Text.Op = PrintName("CastUint64Uint8"); break; case OP_CastUint64Sint8: Text.Op = PrintName("CastUint64Sint8"); break; case OP_CastUint64Uint16: Text.Op = PrintName("CastUint64Uint16"); break; case OP_CastUint64Sint16: Text.Op = PrintName("CastUint64Sint16"); break; case OP_CastUint64Uint32: Text.Op = PrintName("CastUint64Uint32"); break; case OP_CastUint64Sint32: Text.Op = PrintName("CastUint64Sint32"); break; case OP_CastUint64Uint64: Text.Op = PrintName("CastUint64Uint64"); break; case OP_CastUint64Sint64: Text.Op = PrintName("CastUint64Sint64"); break; case OP_CastUint64Bool: Text.Op = PrintName("CastUint64Bool"); break; case OP_CastSint64Uint8: Text.Op = PrintName("CastSint64Uint8"); break; case OP_CastSint64Sint8: Text.Op = PrintName("CastSint64Sint8"); break; case OP_CastSint64Uint16: Text.Op = PrintName("CastSint64Uint16"); break; case OP_CastSint64Sint16: Text.Op = PrintName("CastSint64Sint16"); break; case OP_CastSint64Uint32: Text.Op = PrintName("CastSint64Uint32"); break; case OP_CastSint64Sint32: Text.Op = PrintName("CastSint64Sint32"); break; case OP_CastSint64Uint64: Text.Op = PrintName("CastSint64Uint64"); break; case OP_CastSint64Sint64: Text.Op = PrintName("CastSint64Sint64"); break; case OP_CastSint64Bool: Text.Op = PrintName("CastSint64Bool"); break; case OP_CastBoolUint8: Text.Op = PrintName("CastBoolUint8"); break; case OP_CastBoolSint8: Text.Op = PrintName("CastBoolSint8"); break; case OP_CastBoolUint16: Text.Op = PrintName("CastBoolUint16"); break; case OP_CastBoolSint16: Text.Op = PrintName("CastBoolSint16"); break; case OP_CastBoolUint32: Text.Op = PrintName("CastBoolUint32"); break; case OP_CastBoolSint32: Text.Op = PrintName("CastBoolSint32"); break; case OP_CastBoolUint64: Text.Op = PrintName("CastBoolUint64"); break; case OP_CastBoolSint64: Text.Op = PrintName("CastBoolSint64"); break; case OP_CastBoolBool: Text.Op = PrintName("CastBoolBool"); break; case OP_CastIntAPUint8: Text.Op = PrintName("CastIntAPUint8"); break; case OP_CastIntAPSint8: Text.Op = PrintName("CastIntAPSint8"); break; case OP_CastIntAPUint16: Text.Op = PrintName("CastIntAPUint16"); break; case OP_CastIntAPSint16: Text.Op = PrintName("CastIntAPSint16"); break; case OP_CastIntAPUint32: Text.Op = PrintName("CastIntAPUint32"); break; case OP_CastIntAPSint32: Text.Op = PrintName("CastIntAPSint32"); break; case OP_CastIntAPUint64: Text.Op = PrintName("CastIntAPUint64"); break; case OP_CastIntAPSint64: Text.Op = PrintName("CastIntAPSint64"); break; case OP_CastIntAPBool: Text.Op = PrintName("CastIntAPBool"); break; case OP_CastIntAPSUint8: Text.Op = PrintName("CastIntAPSUint8"); break; case OP_CastIntAPSSint8: Text.Op = PrintName("CastIntAPSSint8"); break; case OP_CastIntAPSUint16: Text.Op = PrintName("CastIntAPSUint16"); break; case OP_CastIntAPSSint16: Text.Op = PrintName("CastIntAPSSint16"); break; case OP_CastIntAPSUint32: Text.Op = PrintName("CastIntAPSUint32"); break; case OP_CastIntAPSSint32: Text.Op = PrintName("CastIntAPSSint32"); break; case OP_CastIntAPSUint64: Text.Op = PrintName("CastIntAPSUint64"); break; case OP_CastIntAPSSint64: Text.Op = PrintName("CastIntAPSSint64"); break; case OP_CastIntAPSBool: Text.Op = PrintName("CastIntAPSBool"); break; case OP_CastFixedPointUint8: Text.Op = PrintName("CastFixedPointUint8"); break; case OP_CastFixedPointSint8: Text.Op = PrintName("CastFixedPointSint8"); break; case OP_CastFixedPointUint16: Text.Op = PrintName("CastFixedPointUint16"); break; case OP_CastFixedPointSint16: Text.Op = PrintName("CastFixedPointSint16"); break; case OP_CastFixedPointUint32: Text.Op = PrintName("CastFixedPointUint32"); break; case OP_CastFixedPointSint32: Text.Op = PrintName("CastFixedPointSint32"); break; case OP_CastFixedPointUint64: Text.Op = PrintName("CastFixedPointUint64"); break; case OP_CastFixedPointSint64: Text.Op = PrintName("CastFixedPointSint64"); break; case OP_CastFixedPointBool: Text.Op = PrintName("CastFixedPointBool"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastUint8Uint8(const SourceInfo &); bool emitCastUint8Sint8(const SourceInfo &); bool emitCastUint8Uint16(const SourceInfo &); bool emitCastUint8Sint16(const SourceInfo &); bool emitCastUint8Uint32(const SourceInfo &); bool emitCastUint8Sint32(const SourceInfo &); bool emitCastUint8Uint64(const SourceInfo &); bool emitCastUint8Sint64(const SourceInfo &); bool emitCastUint8Bool(const SourceInfo &); bool emitCastSint8Uint8(const SourceInfo &); bool emitCastSint8Sint8(const SourceInfo &); bool emitCastSint8Uint16(const SourceInfo &); bool emitCastSint8Sint16(const SourceInfo &); bool emitCastSint8Uint32(const SourceInfo &); bool emitCastSint8Sint32(const SourceInfo &); bool emitCastSint8Uint64(const SourceInfo &); bool emitCastSint8Sint64(const SourceInfo &); bool emitCastSint8Bool(const SourceInfo &); bool emitCastUint16Uint8(const SourceInfo &); bool emitCastUint16Sint8(const SourceInfo &); bool emitCastUint16Uint16(const SourceInfo &); bool emitCastUint16Sint16(const SourceInfo &); bool emitCastUint16Uint32(const SourceInfo &); bool emitCastUint16Sint32(const SourceInfo &); bool emitCastUint16Uint64(const SourceInfo &); bool emitCastUint16Sint64(const SourceInfo &); bool emitCastUint16Bool(const SourceInfo &); bool emitCastSint16Uint8(const SourceInfo &); bool emitCastSint16Sint8(const SourceInfo &); bool emitCastSint16Uint16(const SourceInfo &); bool emitCastSint16Sint16(const SourceInfo &); bool emitCastSint16Uint32(const SourceInfo &); bool emitCastSint16Sint32(const SourceInfo &); bool emitCastSint16Uint64(const SourceInfo &); bool emitCastSint16Sint64(const SourceInfo &); bool emitCastSint16Bool(const SourceInfo &); bool emitCastUint32Uint8(const SourceInfo &); bool emitCastUint32Sint8(const SourceInfo &); bool emitCastUint32Uint16(const SourceInfo &); bool emitCastUint32Sint16(const SourceInfo &); bool emitCastUint32Uint32(const SourceInfo &); bool emitCastUint32Sint32(const SourceInfo &); bool emitCastUint32Uint64(const SourceInfo &); bool emitCastUint32Sint64(const SourceInfo &); bool emitCastUint32Bool(const SourceInfo &); bool emitCastSint32Uint8(const SourceInfo &); bool emitCastSint32Sint8(const SourceInfo &); bool emitCastSint32Uint16(const SourceInfo &); bool emitCastSint32Sint16(const SourceInfo &); bool emitCastSint32Uint32(const SourceInfo &); bool emitCastSint32Sint32(const SourceInfo &); bool emitCastSint32Uint64(const SourceInfo &); bool emitCastSint32Sint64(const SourceInfo &); bool emitCastSint32Bool(const SourceInfo &); bool emitCastUint64Uint8(const SourceInfo &); bool emitCastUint64Sint8(const SourceInfo &); bool emitCastUint64Uint16(const SourceInfo &); bool emitCastUint64Sint16(const SourceInfo &); bool emitCastUint64Uint32(const SourceInfo &); bool emitCastUint64Sint32(const SourceInfo &); bool emitCastUint64Uint64(const SourceInfo &); bool emitCastUint64Sint64(const SourceInfo &); bool emitCastUint64Bool(const SourceInfo &); bool emitCastSint64Uint8(const SourceInfo &); bool emitCastSint64Sint8(const SourceInfo &); bool emitCastSint64Uint16(const SourceInfo &); bool emitCastSint64Sint16(const SourceInfo &); bool emitCastSint64Uint32(const SourceInfo &); bool emitCastSint64Sint32(const SourceInfo &); bool emitCastSint64Uint64(const SourceInfo &); bool emitCastSint64Sint64(const SourceInfo &); bool emitCastSint64Bool(const SourceInfo &); bool emitCastBoolUint8(const SourceInfo &); bool emitCastBoolSint8(const SourceInfo &); bool emitCastBoolUint16(const SourceInfo &); bool emitCastBoolSint16(const SourceInfo &); bool emitCastBoolUint32(const SourceInfo &); bool emitCastBoolSint32(const SourceInfo &); bool emitCastBoolUint64(const SourceInfo &); bool emitCastBoolSint64(const SourceInfo &); bool emitCastBoolBool(const SourceInfo &); bool emitCastIntAPUint8(const SourceInfo &); bool emitCastIntAPSint8(const SourceInfo &); bool emitCastIntAPUint16(const SourceInfo &); bool emitCastIntAPSint16(const SourceInfo &); bool emitCastIntAPUint32(const SourceInfo &); bool emitCastIntAPSint32(const SourceInfo &); bool emitCastIntAPUint64(const SourceInfo &); bool emitCastIntAPSint64(const SourceInfo &); bool emitCastIntAPBool(const SourceInfo &); bool emitCastIntAPSUint8(const SourceInfo &); bool emitCastIntAPSSint8(const SourceInfo &); bool emitCastIntAPSUint16(const SourceInfo &); bool emitCastIntAPSSint16(const SourceInfo &); bool emitCastIntAPSUint32(const SourceInfo &); bool emitCastIntAPSSint32(const SourceInfo &); bool emitCastIntAPSUint64(const SourceInfo &); bool emitCastIntAPSSint64(const SourceInfo &); bool emitCastIntAPSBool(const SourceInfo &); bool emitCastFixedPointUint8(const SourceInfo &); bool emitCastFixedPointSint8(const SourceInfo &); bool emitCastFixedPointUint16(const SourceInfo &); bool emitCastFixedPointSint16(const SourceInfo &); bool emitCastFixedPointUint32(const SourceInfo &); bool emitCastFixedPointSint32(const SourceInfo &); bool emitCastFixedPointUint64(const SourceInfo &); bool emitCastFixedPointSint64(const SourceInfo &); bool emitCastFixedPointBool(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCast(PrimType, PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCast(PrimType T0, PrimType T1, const SourceInfo &I) { switch (T0) { case PT_Uint8: switch (T1) { case PT_Uint8: return emitCastUint8Uint8(I); case PT_Sint8: return emitCastUint8Sint8(I); case PT_Uint16: return emitCastUint8Uint16(I); case PT_Sint16: return emitCastUint8Sint16(I); case PT_Uint32: return emitCastUint8Uint32(I); case PT_Sint32: return emitCastUint8Sint32(I); case PT_Uint64: return emitCastUint8Uint64(I); case PT_Sint64: return emitCastUint8Sint64(I); case PT_Bool: return emitCastUint8Bool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_Sint8: switch (T1) { case PT_Uint8: return emitCastSint8Uint8(I); case PT_Sint8: return emitCastSint8Sint8(I); case PT_Uint16: return emitCastSint8Uint16(I); case PT_Sint16: return emitCastSint8Sint16(I); case PT_Uint32: return emitCastSint8Uint32(I); case PT_Sint32: return emitCastSint8Sint32(I); case PT_Uint64: return emitCastSint8Uint64(I); case PT_Sint64: return emitCastSint8Sint64(I); case PT_Bool: return emitCastSint8Bool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_Uint16: switch (T1) { case PT_Uint8: return emitCastUint16Uint8(I); case PT_Sint8: return emitCastUint16Sint8(I); case PT_Uint16: return emitCastUint16Uint16(I); case PT_Sint16: return emitCastUint16Sint16(I); case PT_Uint32: return emitCastUint16Uint32(I); case PT_Sint32: return emitCastUint16Sint32(I); case PT_Uint64: return emitCastUint16Uint64(I); case PT_Sint64: return emitCastUint16Sint64(I); case PT_Bool: return emitCastUint16Bool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_Sint16: switch (T1) { case PT_Uint8: return emitCastSint16Uint8(I); case PT_Sint8: return emitCastSint16Sint8(I); case PT_Uint16: return emitCastSint16Uint16(I); case PT_Sint16: return emitCastSint16Sint16(I); case PT_Uint32: return emitCastSint16Uint32(I); case PT_Sint32: return emitCastSint16Sint32(I); case PT_Uint64: return emitCastSint16Uint64(I); case PT_Sint64: return emitCastSint16Sint64(I); case PT_Bool: return emitCastSint16Bool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_Uint32: switch (T1) { case PT_Uint8: return emitCastUint32Uint8(I); case PT_Sint8: return emitCastUint32Sint8(I); case PT_Uint16: return emitCastUint32Uint16(I); case PT_Sint16: return emitCastUint32Sint16(I); case PT_Uint32: return emitCastUint32Uint32(I); case PT_Sint32: return emitCastUint32Sint32(I); case PT_Uint64: return emitCastUint32Uint64(I); case PT_Sint64: return emitCastUint32Sint64(I); case PT_Bool: return emitCastUint32Bool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_Sint32: switch (T1) { case PT_Uint8: return emitCastSint32Uint8(I); case PT_Sint8: return emitCastSint32Sint8(I); case PT_Uint16: return emitCastSint32Uint16(I); case PT_Sint16: return emitCastSint32Sint16(I); case PT_Uint32: return emitCastSint32Uint32(I); case PT_Sint32: return emitCastSint32Sint32(I); case PT_Uint64: return emitCastSint32Uint64(I); case PT_Sint64: return emitCastSint32Sint64(I); case PT_Bool: return emitCastSint32Bool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_Uint64: switch (T1) { case PT_Uint8: return emitCastUint64Uint8(I); case PT_Sint8: return emitCastUint64Sint8(I); case PT_Uint16: return emitCastUint64Uint16(I); case PT_Sint16: return emitCastUint64Sint16(I); case PT_Uint32: return emitCastUint64Uint32(I); case PT_Sint32: return emitCastUint64Sint32(I); case PT_Uint64: return emitCastUint64Uint64(I); case PT_Sint64: return emitCastUint64Sint64(I); case PT_Bool: return emitCastUint64Bool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_Sint64: switch (T1) { case PT_Uint8: return emitCastSint64Uint8(I); case PT_Sint8: return emitCastSint64Sint8(I); case PT_Uint16: return emitCastSint64Uint16(I); case PT_Sint16: return emitCastSint64Sint16(I); case PT_Uint32: return emitCastSint64Uint32(I); case PT_Sint32: return emitCastSint64Sint32(I); case PT_Uint64: return emitCastSint64Uint64(I); case PT_Sint64: return emitCastSint64Sint64(I); case PT_Bool: return emitCastSint64Bool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_Bool: switch (T1) { case PT_Uint8: return emitCastBoolUint8(I); case PT_Sint8: return emitCastBoolSint8(I); case PT_Uint16: return emitCastBoolUint16(I); case PT_Sint16: return emitCastBoolSint16(I); case PT_Uint32: return emitCastBoolUint32(I); case PT_Sint32: return emitCastBoolSint32(I); case PT_Uint64: return emitCastBoolUint64(I); case PT_Sint64: return emitCastBoolSint64(I); case PT_Bool: return emitCastBoolBool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_IntAP: switch (T1) { case PT_Uint8: return emitCastIntAPUint8(I); case PT_Sint8: return emitCastIntAPSint8(I); case PT_Uint16: return emitCastIntAPUint16(I); case PT_Sint16: return emitCastIntAPSint16(I); case PT_Uint32: return emitCastIntAPUint32(I); case PT_Sint32: return emitCastIntAPSint32(I); case PT_Uint64: return emitCastIntAPUint64(I); case PT_Sint64: return emitCastIntAPSint64(I); case PT_Bool: return emitCastIntAPBool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_IntAPS: switch (T1) { case PT_Uint8: return emitCastIntAPSUint8(I); case PT_Sint8: return emitCastIntAPSSint8(I); case PT_Uint16: return emitCastIntAPSUint16(I); case PT_Sint16: return emitCastIntAPSSint16(I); case PT_Uint32: return emitCastIntAPSUint32(I); case PT_Sint32: return emitCastIntAPSSint32(I); case PT_Uint64: return emitCastIntAPSUint64(I); case PT_Sint64: return emitCastIntAPSSint64(I); case PT_Bool: return emitCastIntAPSBool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); case PT_FixedPoint: switch (T1) { case PT_Uint8: return emitCastFixedPointUint8(I); case PT_Sint8: return emitCastFixedPointSint8(I); case PT_Uint16: return emitCastFixedPointUint16(I); case PT_Sint16: return emitCastFixedPointSint16(I); case PT_Uint32: return emitCastFixedPointUint32(I); case PT_Sint32: return emitCastFixedPointSint32(I); case PT_Uint64: return emitCastFixedPointUint64(I); case PT_Sint64: return emitCastFixedPointSint64(I); case PT_Bool: return emitCastFixedPointBool(I); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); default: llvm_unreachable("invalid type: emitCast"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastUint8Uint8(const SourceInfo &L) { return emitOp<>(OP_CastUint8Uint8, L); } bool ByteCodeEmitter::emitCastUint8Sint8(const SourceInfo &L) { return emitOp<>(OP_CastUint8Sint8, L); } bool ByteCodeEmitter::emitCastUint8Uint16(const SourceInfo &L) { return emitOp<>(OP_CastUint8Uint16, L); } bool ByteCodeEmitter::emitCastUint8Sint16(const SourceInfo &L) { return emitOp<>(OP_CastUint8Sint16, L); } bool ByteCodeEmitter::emitCastUint8Uint32(const SourceInfo &L) { return emitOp<>(OP_CastUint8Uint32, L); } bool ByteCodeEmitter::emitCastUint8Sint32(const SourceInfo &L) { return emitOp<>(OP_CastUint8Sint32, L); } bool ByteCodeEmitter::emitCastUint8Uint64(const SourceInfo &L) { return emitOp<>(OP_CastUint8Uint64, L); } bool ByteCodeEmitter::emitCastUint8Sint64(const SourceInfo &L) { return emitOp<>(OP_CastUint8Sint64, L); } bool ByteCodeEmitter::emitCastUint8Bool(const SourceInfo &L) { return emitOp<>(OP_CastUint8Bool, L); } bool ByteCodeEmitter::emitCastSint8Uint8(const SourceInfo &L) { return emitOp<>(OP_CastSint8Uint8, L); } bool ByteCodeEmitter::emitCastSint8Sint8(const SourceInfo &L) { return emitOp<>(OP_CastSint8Sint8, L); } bool ByteCodeEmitter::emitCastSint8Uint16(const SourceInfo &L) { return emitOp<>(OP_CastSint8Uint16, L); } bool ByteCodeEmitter::emitCastSint8Sint16(const SourceInfo &L) { return emitOp<>(OP_CastSint8Sint16, L); } bool ByteCodeEmitter::emitCastSint8Uint32(const SourceInfo &L) { return emitOp<>(OP_CastSint8Uint32, L); } bool ByteCodeEmitter::emitCastSint8Sint32(const SourceInfo &L) { return emitOp<>(OP_CastSint8Sint32, L); } bool ByteCodeEmitter::emitCastSint8Uint64(const SourceInfo &L) { return emitOp<>(OP_CastSint8Uint64, L); } bool ByteCodeEmitter::emitCastSint8Sint64(const SourceInfo &L) { return emitOp<>(OP_CastSint8Sint64, L); } bool ByteCodeEmitter::emitCastSint8Bool(const SourceInfo &L) { return emitOp<>(OP_CastSint8Bool, L); } bool ByteCodeEmitter::emitCastUint16Uint8(const SourceInfo &L) { return emitOp<>(OP_CastUint16Uint8, L); } bool ByteCodeEmitter::emitCastUint16Sint8(const SourceInfo &L) { return emitOp<>(OP_CastUint16Sint8, L); } bool ByteCodeEmitter::emitCastUint16Uint16(const SourceInfo &L) { return emitOp<>(OP_CastUint16Uint16, L); } bool ByteCodeEmitter::emitCastUint16Sint16(const SourceInfo &L) { return emitOp<>(OP_CastUint16Sint16, L); } bool ByteCodeEmitter::emitCastUint16Uint32(const SourceInfo &L) { return emitOp<>(OP_CastUint16Uint32, L); } bool ByteCodeEmitter::emitCastUint16Sint32(const SourceInfo &L) { return emitOp<>(OP_CastUint16Sint32, L); } bool ByteCodeEmitter::emitCastUint16Uint64(const SourceInfo &L) { return emitOp<>(OP_CastUint16Uint64, L); } bool ByteCodeEmitter::emitCastUint16Sint64(const SourceInfo &L) { return emitOp<>(OP_CastUint16Sint64, L); } bool ByteCodeEmitter::emitCastUint16Bool(const SourceInfo &L) { return emitOp<>(OP_CastUint16Bool, L); } bool ByteCodeEmitter::emitCastSint16Uint8(const SourceInfo &L) { return emitOp<>(OP_CastSint16Uint8, L); } bool ByteCodeEmitter::emitCastSint16Sint8(const SourceInfo &L) { return emitOp<>(OP_CastSint16Sint8, L); } bool ByteCodeEmitter::emitCastSint16Uint16(const SourceInfo &L) { return emitOp<>(OP_CastSint16Uint16, L); } bool ByteCodeEmitter::emitCastSint16Sint16(const SourceInfo &L) { return emitOp<>(OP_CastSint16Sint16, L); } bool ByteCodeEmitter::emitCastSint16Uint32(const SourceInfo &L) { return emitOp<>(OP_CastSint16Uint32, L); } bool ByteCodeEmitter::emitCastSint16Sint32(const SourceInfo &L) { return emitOp<>(OP_CastSint16Sint32, L); } bool ByteCodeEmitter::emitCastSint16Uint64(const SourceInfo &L) { return emitOp<>(OP_CastSint16Uint64, L); } bool ByteCodeEmitter::emitCastSint16Sint64(const SourceInfo &L) { return emitOp<>(OP_CastSint16Sint64, L); } bool ByteCodeEmitter::emitCastSint16Bool(const SourceInfo &L) { return emitOp<>(OP_CastSint16Bool, L); } bool ByteCodeEmitter::emitCastUint32Uint8(const SourceInfo &L) { return emitOp<>(OP_CastUint32Uint8, L); } bool ByteCodeEmitter::emitCastUint32Sint8(const SourceInfo &L) { return emitOp<>(OP_CastUint32Sint8, L); } bool ByteCodeEmitter::emitCastUint32Uint16(const SourceInfo &L) { return emitOp<>(OP_CastUint32Uint16, L); } bool ByteCodeEmitter::emitCastUint32Sint16(const SourceInfo &L) { return emitOp<>(OP_CastUint32Sint16, L); } bool ByteCodeEmitter::emitCastUint32Uint32(const SourceInfo &L) { return emitOp<>(OP_CastUint32Uint32, L); } bool ByteCodeEmitter::emitCastUint32Sint32(const SourceInfo &L) { return emitOp<>(OP_CastUint32Sint32, L); } bool ByteCodeEmitter::emitCastUint32Uint64(const SourceInfo &L) { return emitOp<>(OP_CastUint32Uint64, L); } bool ByteCodeEmitter::emitCastUint32Sint64(const SourceInfo &L) { return emitOp<>(OP_CastUint32Sint64, L); } bool ByteCodeEmitter::emitCastUint32Bool(const SourceInfo &L) { return emitOp<>(OP_CastUint32Bool, L); } bool ByteCodeEmitter::emitCastSint32Uint8(const SourceInfo &L) { return emitOp<>(OP_CastSint32Uint8, L); } bool ByteCodeEmitter::emitCastSint32Sint8(const SourceInfo &L) { return emitOp<>(OP_CastSint32Sint8, L); } bool ByteCodeEmitter::emitCastSint32Uint16(const SourceInfo &L) { return emitOp<>(OP_CastSint32Uint16, L); } bool ByteCodeEmitter::emitCastSint32Sint16(const SourceInfo &L) { return emitOp<>(OP_CastSint32Sint16, L); } bool ByteCodeEmitter::emitCastSint32Uint32(const SourceInfo &L) { return emitOp<>(OP_CastSint32Uint32, L); } bool ByteCodeEmitter::emitCastSint32Sint32(const SourceInfo &L) { return emitOp<>(OP_CastSint32Sint32, L); } bool ByteCodeEmitter::emitCastSint32Uint64(const SourceInfo &L) { return emitOp<>(OP_CastSint32Uint64, L); } bool ByteCodeEmitter::emitCastSint32Sint64(const SourceInfo &L) { return emitOp<>(OP_CastSint32Sint64, L); } bool ByteCodeEmitter::emitCastSint32Bool(const SourceInfo &L) { return emitOp<>(OP_CastSint32Bool, L); } bool ByteCodeEmitter::emitCastUint64Uint8(const SourceInfo &L) { return emitOp<>(OP_CastUint64Uint8, L); } bool ByteCodeEmitter::emitCastUint64Sint8(const SourceInfo &L) { return emitOp<>(OP_CastUint64Sint8, L); } bool ByteCodeEmitter::emitCastUint64Uint16(const SourceInfo &L) { return emitOp<>(OP_CastUint64Uint16, L); } bool ByteCodeEmitter::emitCastUint64Sint16(const SourceInfo &L) { return emitOp<>(OP_CastUint64Sint16, L); } bool ByteCodeEmitter::emitCastUint64Uint32(const SourceInfo &L) { return emitOp<>(OP_CastUint64Uint32, L); } bool ByteCodeEmitter::emitCastUint64Sint32(const SourceInfo &L) { return emitOp<>(OP_CastUint64Sint32, L); } bool ByteCodeEmitter::emitCastUint64Uint64(const SourceInfo &L) { return emitOp<>(OP_CastUint64Uint64, L); } bool ByteCodeEmitter::emitCastUint64Sint64(const SourceInfo &L) { return emitOp<>(OP_CastUint64Sint64, L); } bool ByteCodeEmitter::emitCastUint64Bool(const SourceInfo &L) { return emitOp<>(OP_CastUint64Bool, L); } bool ByteCodeEmitter::emitCastSint64Uint8(const SourceInfo &L) { return emitOp<>(OP_CastSint64Uint8, L); } bool ByteCodeEmitter::emitCastSint64Sint8(const SourceInfo &L) { return emitOp<>(OP_CastSint64Sint8, L); } bool ByteCodeEmitter::emitCastSint64Uint16(const SourceInfo &L) { return emitOp<>(OP_CastSint64Uint16, L); } bool ByteCodeEmitter::emitCastSint64Sint16(const SourceInfo &L) { return emitOp<>(OP_CastSint64Sint16, L); } bool ByteCodeEmitter::emitCastSint64Uint32(const SourceInfo &L) { return emitOp<>(OP_CastSint64Uint32, L); } bool ByteCodeEmitter::emitCastSint64Sint32(const SourceInfo &L) { return emitOp<>(OP_CastSint64Sint32, L); } bool ByteCodeEmitter::emitCastSint64Uint64(const SourceInfo &L) { return emitOp<>(OP_CastSint64Uint64, L); } bool ByteCodeEmitter::emitCastSint64Sint64(const SourceInfo &L) { return emitOp<>(OP_CastSint64Sint64, L); } bool ByteCodeEmitter::emitCastSint64Bool(const SourceInfo &L) { return emitOp<>(OP_CastSint64Bool, L); } bool ByteCodeEmitter::emitCastBoolUint8(const SourceInfo &L) { return emitOp<>(OP_CastBoolUint8, L); } bool ByteCodeEmitter::emitCastBoolSint8(const SourceInfo &L) { return emitOp<>(OP_CastBoolSint8, L); } bool ByteCodeEmitter::emitCastBoolUint16(const SourceInfo &L) { return emitOp<>(OP_CastBoolUint16, L); } bool ByteCodeEmitter::emitCastBoolSint16(const SourceInfo &L) { return emitOp<>(OP_CastBoolSint16, L); } bool ByteCodeEmitter::emitCastBoolUint32(const SourceInfo &L) { return emitOp<>(OP_CastBoolUint32, L); } bool ByteCodeEmitter::emitCastBoolSint32(const SourceInfo &L) { return emitOp<>(OP_CastBoolSint32, L); } bool ByteCodeEmitter::emitCastBoolUint64(const SourceInfo &L) { return emitOp<>(OP_CastBoolUint64, L); } bool ByteCodeEmitter::emitCastBoolSint64(const SourceInfo &L) { return emitOp<>(OP_CastBoolSint64, L); } bool ByteCodeEmitter::emitCastBoolBool(const SourceInfo &L) { return emitOp<>(OP_CastBoolBool, L); } bool ByteCodeEmitter::emitCastIntAPUint8(const SourceInfo &L) { return emitOp<>(OP_CastIntAPUint8, L); } bool ByteCodeEmitter::emitCastIntAPSint8(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSint8, L); } bool ByteCodeEmitter::emitCastIntAPUint16(const SourceInfo &L) { return emitOp<>(OP_CastIntAPUint16, L); } bool ByteCodeEmitter::emitCastIntAPSint16(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSint16, L); } bool ByteCodeEmitter::emitCastIntAPUint32(const SourceInfo &L) { return emitOp<>(OP_CastIntAPUint32, L); } bool ByteCodeEmitter::emitCastIntAPSint32(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSint32, L); } bool ByteCodeEmitter::emitCastIntAPUint64(const SourceInfo &L) { return emitOp<>(OP_CastIntAPUint64, L); } bool ByteCodeEmitter::emitCastIntAPSint64(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSint64, L); } bool ByteCodeEmitter::emitCastIntAPBool(const SourceInfo &L) { return emitOp<>(OP_CastIntAPBool, L); } bool ByteCodeEmitter::emitCastIntAPSUint8(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSUint8, L); } bool ByteCodeEmitter::emitCastIntAPSSint8(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSSint8, L); } bool ByteCodeEmitter::emitCastIntAPSUint16(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSUint16, L); } bool ByteCodeEmitter::emitCastIntAPSSint16(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSSint16, L); } bool ByteCodeEmitter::emitCastIntAPSUint32(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSUint32, L); } bool ByteCodeEmitter::emitCastIntAPSSint32(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSSint32, L); } bool ByteCodeEmitter::emitCastIntAPSUint64(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSUint64, L); } bool ByteCodeEmitter::emitCastIntAPSSint64(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSSint64, L); } bool ByteCodeEmitter::emitCastIntAPSBool(const SourceInfo &L) { return emitOp<>(OP_CastIntAPSBool, L); } bool ByteCodeEmitter::emitCastFixedPointUint8(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointUint8, L); } bool ByteCodeEmitter::emitCastFixedPointSint8(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointSint8, L); } bool ByteCodeEmitter::emitCastFixedPointUint16(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointUint16, L); } bool ByteCodeEmitter::emitCastFixedPointSint16(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointSint16, L); } bool ByteCodeEmitter::emitCastFixedPointUint32(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointUint32, L); } bool ByteCodeEmitter::emitCastFixedPointSint32(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointSint32, L); } bool ByteCodeEmitter::emitCastFixedPointUint64(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointUint64, L); } bool ByteCodeEmitter::emitCastFixedPointSint64(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointSint64, L); } bool ByteCodeEmitter::emitCastFixedPointBool(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointBool, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastUint8Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint8Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint8Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint8Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint8Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint8Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint8Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint8Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint8Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint8Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint8Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint8Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint8Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint8Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint8Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint8Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint8Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint8Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint16Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint16Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint16Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint16Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint16Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint16Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint16Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint16Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint16Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint16Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint16Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint16Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint16Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint16Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint16Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint16Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint16Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint16Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint32Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint32Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint32Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint32Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint32Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint32Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint32Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint32Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint32Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint32Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint32Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint32Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint32Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint32Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint32Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint32Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint32Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint32Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint64Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint64Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint64Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint64Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint64Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint64Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint64Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint64Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastUint64Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint64Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint64Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint64Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint64Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint64Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint64Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint64Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint64Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastSint64Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastBoolUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastBoolSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastBoolUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastBoolSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastBoolUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastBoolSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastBoolUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastBoolSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastBoolBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastIntAPSBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastFixedPointUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastFixedPointSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastFixedPointUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastFixedPointSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastFixedPointUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastFixedPointSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastFixedPointUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastFixedPointSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } bool EvalEmitter::emitCastFixedPointBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Cast(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CastAPSint8, OP_CastAPUint8, OP_CastAPSint16, OP_CastAPUint16, OP_CastAPSint32, OP_CastAPUint32, OP_CastAPSint64, OP_CastAPUint64, OP_CastAPIntAP, OP_CastAPIntAPS, OP_CastAPBool, OP_CastAPFixedPoint, #endif #ifdef GET_INTERP case OP_CastAPSint8: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPUint8: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPSint16: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPUint16: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPSint32: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPUint32: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPSint64: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPUint64: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPIntAP: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPIntAPS: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPBool: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } case OP_CastAPFixedPoint: { const auto V0 = ReadArg(S, PC); if (!CastAP(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastAPSint8: Text.Op = PrintName("CastAPSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPUint8: Text.Op = PrintName("CastAPUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSint16: Text.Op = PrintName("CastAPSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPUint16: Text.Op = PrintName("CastAPUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSint32: Text.Op = PrintName("CastAPSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPUint32: Text.Op = PrintName("CastAPUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSint64: Text.Op = PrintName("CastAPSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPUint64: Text.Op = PrintName("CastAPUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPIntAP: Text.Op = PrintName("CastAPIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPIntAPS: Text.Op = PrintName("CastAPIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPBool: Text.Op = PrintName("CastAPBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPFixedPoint: Text.Op = PrintName("CastAPFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastAPSint8( uint32_t , const SourceInfo &); bool emitCastAPUint8( uint32_t , const SourceInfo &); bool emitCastAPSint16( uint32_t , const SourceInfo &); bool emitCastAPUint16( uint32_t , const SourceInfo &); bool emitCastAPSint32( uint32_t , const SourceInfo &); bool emitCastAPUint32( uint32_t , const SourceInfo &); bool emitCastAPSint64( uint32_t , const SourceInfo &); bool emitCastAPUint64( uint32_t , const SourceInfo &); bool emitCastAPIntAP( uint32_t , const SourceInfo &); bool emitCastAPIntAPS( uint32_t , const SourceInfo &); bool emitCastAPBool( uint32_t , const SourceInfo &); bool emitCastAPFixedPoint( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCastAP(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCastAP(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCastAPSint8(A0, I); case PT_Uint8: return emitCastAPUint8(A0, I); case PT_Sint16: return emitCastAPSint16(A0, I); case PT_Uint16: return emitCastAPUint16(A0, I); case PT_Sint32: return emitCastAPSint32(A0, I); case PT_Uint32: return emitCastAPUint32(A0, I); case PT_Sint64: return emitCastAPSint64(A0, I); case PT_Uint64: return emitCastAPUint64(A0, I); case PT_IntAP: return emitCastAPIntAP(A0, I); case PT_IntAPS: return emitCastAPIntAPS(A0, I); case PT_Bool: return emitCastAPBool(A0, I); case PT_FixedPoint: return emitCastAPFixedPoint(A0, I); default: llvm_unreachable("invalid type: emitCastAP"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastAPSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSint8, A0, L); } bool ByteCodeEmitter::emitCastAPUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPUint8, A0, L); } bool ByteCodeEmitter::emitCastAPSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSint16, A0, L); } bool ByteCodeEmitter::emitCastAPUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPUint16, A0, L); } bool ByteCodeEmitter::emitCastAPSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSint32, A0, L); } bool ByteCodeEmitter::emitCastAPUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPUint32, A0, L); } bool ByteCodeEmitter::emitCastAPSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSint64, A0, L); } bool ByteCodeEmitter::emitCastAPUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPUint64, A0, L); } bool ByteCodeEmitter::emitCastAPIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPIntAP, A0, L); } bool ByteCodeEmitter::emitCastAPIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPIntAPS, A0, L); } bool ByteCodeEmitter::emitCastAPBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPBool, A0, L); } bool ByteCodeEmitter::emitCastAPFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastAPSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } bool EvalEmitter::emitCastAPFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAP(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CastAPSSint8, OP_CastAPSUint8, OP_CastAPSSint16, OP_CastAPSUint16, OP_CastAPSSint32, OP_CastAPSUint32, OP_CastAPSSint64, OP_CastAPSUint64, OP_CastAPSIntAP, OP_CastAPSIntAPS, OP_CastAPSBool, OP_CastAPSFixedPoint, #endif #ifdef GET_INTERP case OP_CastAPSSint8: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSUint8: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSSint16: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSUint16: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSSint32: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSUint32: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSSint64: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSUint64: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSIntAP: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSIntAPS: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSBool: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } case OP_CastAPSFixedPoint: { const auto V0 = ReadArg(S, PC); if (!CastAPS(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastAPSSint8: Text.Op = PrintName("CastAPSSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSUint8: Text.Op = PrintName("CastAPSUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSSint16: Text.Op = PrintName("CastAPSSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSUint16: Text.Op = PrintName("CastAPSUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSSint32: Text.Op = PrintName("CastAPSSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSUint32: Text.Op = PrintName("CastAPSUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSSint64: Text.Op = PrintName("CastAPSSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSUint64: Text.Op = PrintName("CastAPSUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSIntAP: Text.Op = PrintName("CastAPSIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSIntAPS: Text.Op = PrintName("CastAPSIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSBool: Text.Op = PrintName("CastAPSBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastAPSFixedPoint: Text.Op = PrintName("CastAPSFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastAPSSint8( uint32_t , const SourceInfo &); bool emitCastAPSUint8( uint32_t , const SourceInfo &); bool emitCastAPSSint16( uint32_t , const SourceInfo &); bool emitCastAPSUint16( uint32_t , const SourceInfo &); bool emitCastAPSSint32( uint32_t , const SourceInfo &); bool emitCastAPSUint32( uint32_t , const SourceInfo &); bool emitCastAPSSint64( uint32_t , const SourceInfo &); bool emitCastAPSUint64( uint32_t , const SourceInfo &); bool emitCastAPSIntAP( uint32_t , const SourceInfo &); bool emitCastAPSIntAPS( uint32_t , const SourceInfo &); bool emitCastAPSBool( uint32_t , const SourceInfo &); bool emitCastAPSFixedPoint( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCastAPS(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCastAPS(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCastAPSSint8(A0, I); case PT_Uint8: return emitCastAPSUint8(A0, I); case PT_Sint16: return emitCastAPSSint16(A0, I); case PT_Uint16: return emitCastAPSUint16(A0, I); case PT_Sint32: return emitCastAPSSint32(A0, I); case PT_Uint32: return emitCastAPSUint32(A0, I); case PT_Sint64: return emitCastAPSSint64(A0, I); case PT_Uint64: return emitCastAPSUint64(A0, I); case PT_IntAP: return emitCastAPSIntAP(A0, I); case PT_IntAPS: return emitCastAPSIntAPS(A0, I); case PT_Bool: return emitCastAPSBool(A0, I); case PT_FixedPoint: return emitCastAPSFixedPoint(A0, I); default: llvm_unreachable("invalid type: emitCastAPS"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastAPSSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSSint8, A0, L); } bool ByteCodeEmitter::emitCastAPSUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSUint8, A0, L); } bool ByteCodeEmitter::emitCastAPSSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSSint16, A0, L); } bool ByteCodeEmitter::emitCastAPSUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSUint16, A0, L); } bool ByteCodeEmitter::emitCastAPSSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSSint32, A0, L); } bool ByteCodeEmitter::emitCastAPSUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSUint32, A0, L); } bool ByteCodeEmitter::emitCastAPSSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSSint64, A0, L); } bool ByteCodeEmitter::emitCastAPSUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSUint64, A0, L); } bool ByteCodeEmitter::emitCastAPSIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSIntAP, A0, L); } bool ByteCodeEmitter::emitCastAPSIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSIntAPS, A0, L); } bool ByteCodeEmitter::emitCastAPSBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSBool, A0, L); } bool ByteCodeEmitter::emitCastAPSFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastAPSFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastAPSSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } bool EvalEmitter::emitCastAPSFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastAPS(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CastFP, #endif #ifdef GET_INTERP case OP_CastFP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastFP(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastFP: Text.Op = PrintName("CastFP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastFP( const llvm::fltSemantics * , llvm::RoundingMode , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastFP( const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) { return emitOp(OP_CastFP, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastFP( const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFP(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_CastFixedPoint, #endif #ifdef GET_INTERP case OP_CastFixedPoint: { const auto V0 = ReadArg(S, PC); if (!CastFixedPoint(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastFixedPoint: Text.Op = PrintName("CastFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastFixedPoint( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPoint(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CastFixedPointFloating, #endif #ifdef GET_INTERP case OP_CastFixedPointFloating: { const auto V0 = ReadArg(S, PC); if (!CastFixedPointFloating(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastFixedPointFloating: Text.Op = PrintName("CastFixedPointFloating"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastFixedPointFloating( const llvm::fltSemantics * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastFixedPointFloating( const llvm::fltSemantics * A0, const SourceInfo &L) { return emitOp(OP_CastFixedPointFloating, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastFixedPointFloating( const llvm::fltSemantics * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPointFloating(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CastFixedPointIntegralSint8, OP_CastFixedPointIntegralUint8, OP_CastFixedPointIntegralSint16, OP_CastFixedPointIntegralUint16, OP_CastFixedPointIntegralSint32, OP_CastFixedPointIntegralUint32, OP_CastFixedPointIntegralSint64, OP_CastFixedPointIntegralUint64, #endif #ifdef GET_INTERP case OP_CastFixedPointIntegralSint8: { if (!CastFixedPointIntegral(S, OpPC)) return false; continue; } case OP_CastFixedPointIntegralUint8: { if (!CastFixedPointIntegral(S, OpPC)) return false; continue; } case OP_CastFixedPointIntegralSint16: { if (!CastFixedPointIntegral(S, OpPC)) return false; continue; } case OP_CastFixedPointIntegralUint16: { if (!CastFixedPointIntegral(S, OpPC)) return false; continue; } case OP_CastFixedPointIntegralSint32: { if (!CastFixedPointIntegral(S, OpPC)) return false; continue; } case OP_CastFixedPointIntegralUint32: { if (!CastFixedPointIntegral(S, OpPC)) return false; continue; } case OP_CastFixedPointIntegralSint64: { if (!CastFixedPointIntegral(S, OpPC)) return false; continue; } case OP_CastFixedPointIntegralUint64: { if (!CastFixedPointIntegral(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastFixedPointIntegralSint8: Text.Op = PrintName("CastFixedPointIntegralSint8"); break; case OP_CastFixedPointIntegralUint8: Text.Op = PrintName("CastFixedPointIntegralUint8"); break; case OP_CastFixedPointIntegralSint16: Text.Op = PrintName("CastFixedPointIntegralSint16"); break; case OP_CastFixedPointIntegralUint16: Text.Op = PrintName("CastFixedPointIntegralUint16"); break; case OP_CastFixedPointIntegralSint32: Text.Op = PrintName("CastFixedPointIntegralSint32"); break; case OP_CastFixedPointIntegralUint32: Text.Op = PrintName("CastFixedPointIntegralUint32"); break; case OP_CastFixedPointIntegralSint64: Text.Op = PrintName("CastFixedPointIntegralSint64"); break; case OP_CastFixedPointIntegralUint64: Text.Op = PrintName("CastFixedPointIntegralUint64"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastFixedPointIntegralSint8(const SourceInfo &); bool emitCastFixedPointIntegralUint8(const SourceInfo &); bool emitCastFixedPointIntegralSint16(const SourceInfo &); bool emitCastFixedPointIntegralUint16(const SourceInfo &); bool emitCastFixedPointIntegralSint32(const SourceInfo &); bool emitCastFixedPointIntegralUint32(const SourceInfo &); bool emitCastFixedPointIntegralSint64(const SourceInfo &); bool emitCastFixedPointIntegralUint64(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCastFixedPointIntegral(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCastFixedPointIntegral(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCastFixedPointIntegralSint8(I); case PT_Uint8: return emitCastFixedPointIntegralUint8(I); case PT_Sint16: return emitCastFixedPointIntegralSint16(I); case PT_Uint16: return emitCastFixedPointIntegralUint16(I); case PT_Sint32: return emitCastFixedPointIntegralSint32(I); case PT_Uint32: return emitCastFixedPointIntegralUint32(I); case PT_Sint64: return emitCastFixedPointIntegralSint64(I); case PT_Uint64: return emitCastFixedPointIntegralUint64(I); default: llvm_unreachable("invalid type: emitCastFixedPointIntegral"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastFixedPointIntegralSint8(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointIntegralSint8, L); } bool ByteCodeEmitter::emitCastFixedPointIntegralUint8(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointIntegralUint8, L); } bool ByteCodeEmitter::emitCastFixedPointIntegralSint16(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointIntegralSint16, L); } bool ByteCodeEmitter::emitCastFixedPointIntegralUint16(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointIntegralUint16, L); } bool ByteCodeEmitter::emitCastFixedPointIntegralSint32(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointIntegralSint32, L); } bool ByteCodeEmitter::emitCastFixedPointIntegralUint32(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointIntegralUint32, L); } bool ByteCodeEmitter::emitCastFixedPointIntegralSint64(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointIntegralSint64, L); } bool ByteCodeEmitter::emitCastFixedPointIntegralUint64(const SourceInfo &L) { return emitOp<>(OP_CastFixedPointIntegralUint64, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastFixedPointIntegralSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPointIntegral(S, OpPC); } bool EvalEmitter::emitCastFixedPointIntegralUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPointIntegral(S, OpPC); } bool EvalEmitter::emitCastFixedPointIntegralSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPointIntegral(S, OpPC); } bool EvalEmitter::emitCastFixedPointIntegralUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPointIntegral(S, OpPC); } bool EvalEmitter::emitCastFixedPointIntegralSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPointIntegral(S, OpPC); } bool EvalEmitter::emitCastFixedPointIntegralUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPointIntegral(S, OpPC); } bool EvalEmitter::emitCastFixedPointIntegralSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPointIntegral(S, OpPC); } bool EvalEmitter::emitCastFixedPointIntegralUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFixedPointIntegral(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CastFloatingFixedPoint, #endif #ifdef GET_INTERP case OP_CastFloatingFixedPoint: { const auto V0 = ReadArg(S, PC); if (!CastFloatingFixedPoint(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastFloatingFixedPoint: Text.Op = PrintName("CastFloatingFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastFloatingFixedPoint( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastFloatingFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastFloatingFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingFixedPoint(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CastFloatingIntegralSint8, OP_CastFloatingIntegralUint8, OP_CastFloatingIntegralSint16, OP_CastFloatingIntegralUint16, OP_CastFloatingIntegralSint32, OP_CastFloatingIntegralUint32, OP_CastFloatingIntegralSint64, OP_CastFloatingIntegralUint64, OP_CastFloatingIntegralBool, #endif #ifdef GET_INTERP case OP_CastFloatingIntegralSint8: { const auto V0 = ReadArg(S, PC); if (!CastFloatingIntegral(S, OpPC, V0)) return false; continue; } case OP_CastFloatingIntegralUint8: { const auto V0 = ReadArg(S, PC); if (!CastFloatingIntegral(S, OpPC, V0)) return false; continue; } case OP_CastFloatingIntegralSint16: { const auto V0 = ReadArg(S, PC); if (!CastFloatingIntegral(S, OpPC, V0)) return false; continue; } case OP_CastFloatingIntegralUint16: { const auto V0 = ReadArg(S, PC); if (!CastFloatingIntegral(S, OpPC, V0)) return false; continue; } case OP_CastFloatingIntegralSint32: { const auto V0 = ReadArg(S, PC); if (!CastFloatingIntegral(S, OpPC, V0)) return false; continue; } case OP_CastFloatingIntegralUint32: { const auto V0 = ReadArg(S, PC); if (!CastFloatingIntegral(S, OpPC, V0)) return false; continue; } case OP_CastFloatingIntegralSint64: { const auto V0 = ReadArg(S, PC); if (!CastFloatingIntegral(S, OpPC, V0)) return false; continue; } case OP_CastFloatingIntegralUint64: { const auto V0 = ReadArg(S, PC); if (!CastFloatingIntegral(S, OpPC, V0)) return false; continue; } case OP_CastFloatingIntegralBool: { const auto V0 = ReadArg(S, PC); if (!CastFloatingIntegral(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastFloatingIntegralSint8: Text.Op = PrintName("CastFloatingIntegralSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastFloatingIntegralUint8: Text.Op = PrintName("CastFloatingIntegralUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastFloatingIntegralSint16: Text.Op = PrintName("CastFloatingIntegralSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastFloatingIntegralUint16: Text.Op = PrintName("CastFloatingIntegralUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastFloatingIntegralSint32: Text.Op = PrintName("CastFloatingIntegralSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastFloatingIntegralUint32: Text.Op = PrintName("CastFloatingIntegralUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastFloatingIntegralSint64: Text.Op = PrintName("CastFloatingIntegralSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastFloatingIntegralUint64: Text.Op = PrintName("CastFloatingIntegralUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastFloatingIntegralBool: Text.Op = PrintName("CastFloatingIntegralBool"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastFloatingIntegralSint8( uint32_t , const SourceInfo &); bool emitCastFloatingIntegralUint8( uint32_t , const SourceInfo &); bool emitCastFloatingIntegralSint16( uint32_t , const SourceInfo &); bool emitCastFloatingIntegralUint16( uint32_t , const SourceInfo &); bool emitCastFloatingIntegralSint32( uint32_t , const SourceInfo &); bool emitCastFloatingIntegralUint32( uint32_t , const SourceInfo &); bool emitCastFloatingIntegralSint64( uint32_t , const SourceInfo &); bool emitCastFloatingIntegralUint64( uint32_t , const SourceInfo &); bool emitCastFloatingIntegralBool( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCastFloatingIntegral(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCastFloatingIntegral(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCastFloatingIntegralSint8(A0, I); case PT_Uint8: return emitCastFloatingIntegralUint8(A0, I); case PT_Sint16: return emitCastFloatingIntegralSint16(A0, I); case PT_Uint16: return emitCastFloatingIntegralUint16(A0, I); case PT_Sint32: return emitCastFloatingIntegralSint32(A0, I); case PT_Uint32: return emitCastFloatingIntegralUint32(A0, I); case PT_Sint64: return emitCastFloatingIntegralSint64(A0, I); case PT_Uint64: return emitCastFloatingIntegralUint64(A0, I); case PT_Bool: return emitCastFloatingIntegralBool(A0, I); default: llvm_unreachable("invalid type: emitCastFloatingIntegral"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastFloatingIntegralSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralSint8, A0, L); } bool ByteCodeEmitter::emitCastFloatingIntegralUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralUint8, A0, L); } bool ByteCodeEmitter::emitCastFloatingIntegralSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralSint16, A0, L); } bool ByteCodeEmitter::emitCastFloatingIntegralUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralUint16, A0, L); } bool ByteCodeEmitter::emitCastFloatingIntegralSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralSint32, A0, L); } bool ByteCodeEmitter::emitCastFloatingIntegralUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralUint32, A0, L); } bool ByteCodeEmitter::emitCastFloatingIntegralSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralSint64, A0, L); } bool ByteCodeEmitter::emitCastFloatingIntegralUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralUint64, A0, L); } bool ByteCodeEmitter::emitCastFloatingIntegralBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralBool, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastFloatingIntegralSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegral(S, OpPC, A0); } bool EvalEmitter::emitCastFloatingIntegralUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegral(S, OpPC, A0); } bool EvalEmitter::emitCastFloatingIntegralSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegral(S, OpPC, A0); } bool EvalEmitter::emitCastFloatingIntegralUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegral(S, OpPC, A0); } bool EvalEmitter::emitCastFloatingIntegralSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegral(S, OpPC, A0); } bool EvalEmitter::emitCastFloatingIntegralUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegral(S, OpPC, A0); } bool EvalEmitter::emitCastFloatingIntegralSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegral(S, OpPC, A0); } bool EvalEmitter::emitCastFloatingIntegralUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegral(S, OpPC, A0); } bool EvalEmitter::emitCastFloatingIntegralBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegral(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CastFloatingIntegralAP, #endif #ifdef GET_INTERP case OP_CastFloatingIntegralAP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastFloatingIntegralAP(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastFloatingIntegralAP: Text.Op = PrintName("CastFloatingIntegralAP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastFloatingIntegralAP( uint32_t , uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastFloatingIntegralAP( uint32_t A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralAP, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastFloatingIntegralAP( uint32_t A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegralAP(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_CastFloatingIntegralAPS, #endif #ifdef GET_INTERP case OP_CastFloatingIntegralAPS: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastFloatingIntegralAPS(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastFloatingIntegralAPS: Text.Op = PrintName("CastFloatingIntegralAPS"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastFloatingIntegralAPS( uint32_t , uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastFloatingIntegralAPS( uint32_t A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastFloatingIntegralAPS, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastFloatingIntegralAPS( uint32_t A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastFloatingIntegralAPS(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_CastIntegralFixedPointSint8, OP_CastIntegralFixedPointUint8, OP_CastIntegralFixedPointSint16, OP_CastIntegralFixedPointUint16, OP_CastIntegralFixedPointSint32, OP_CastIntegralFixedPointUint32, OP_CastIntegralFixedPointSint64, OP_CastIntegralFixedPointUint64, OP_CastIntegralFixedPointBool, #endif #ifdef GET_INTERP case OP_CastIntegralFixedPointSint8: { const auto V0 = ReadArg(S, PC); if (!CastIntegralFixedPoint(S, OpPC, V0)) return false; continue; } case OP_CastIntegralFixedPointUint8: { const auto V0 = ReadArg(S, PC); if (!CastIntegralFixedPoint(S, OpPC, V0)) return false; continue; } case OP_CastIntegralFixedPointSint16: { const auto V0 = ReadArg(S, PC); if (!CastIntegralFixedPoint(S, OpPC, V0)) return false; continue; } case OP_CastIntegralFixedPointUint16: { const auto V0 = ReadArg(S, PC); if (!CastIntegralFixedPoint(S, OpPC, V0)) return false; continue; } case OP_CastIntegralFixedPointSint32: { const auto V0 = ReadArg(S, PC); if (!CastIntegralFixedPoint(S, OpPC, V0)) return false; continue; } case OP_CastIntegralFixedPointUint32: { const auto V0 = ReadArg(S, PC); if (!CastIntegralFixedPoint(S, OpPC, V0)) return false; continue; } case OP_CastIntegralFixedPointSint64: { const auto V0 = ReadArg(S, PC); if (!CastIntegralFixedPoint(S, OpPC, V0)) return false; continue; } case OP_CastIntegralFixedPointUint64: { const auto V0 = ReadArg(S, PC); if (!CastIntegralFixedPoint(S, OpPC, V0)) return false; continue; } case OP_CastIntegralFixedPointBool: { const auto V0 = ReadArg(S, PC); if (!CastIntegralFixedPoint(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastIntegralFixedPointSint8: Text.Op = PrintName("CastIntegralFixedPointSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFixedPointUint8: Text.Op = PrintName("CastIntegralFixedPointUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFixedPointSint16: Text.Op = PrintName("CastIntegralFixedPointSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFixedPointUint16: Text.Op = PrintName("CastIntegralFixedPointUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFixedPointSint32: Text.Op = PrintName("CastIntegralFixedPointSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFixedPointUint32: Text.Op = PrintName("CastIntegralFixedPointUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFixedPointSint64: Text.Op = PrintName("CastIntegralFixedPointSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFixedPointUint64: Text.Op = PrintName("CastIntegralFixedPointUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFixedPointBool: Text.Op = PrintName("CastIntegralFixedPointBool"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastIntegralFixedPointSint8( uint32_t , const SourceInfo &); bool emitCastIntegralFixedPointUint8( uint32_t , const SourceInfo &); bool emitCastIntegralFixedPointSint16( uint32_t , const SourceInfo &); bool emitCastIntegralFixedPointUint16( uint32_t , const SourceInfo &); bool emitCastIntegralFixedPointSint32( uint32_t , const SourceInfo &); bool emitCastIntegralFixedPointUint32( uint32_t , const SourceInfo &); bool emitCastIntegralFixedPointSint64( uint32_t , const SourceInfo &); bool emitCastIntegralFixedPointUint64( uint32_t , const SourceInfo &); bool emitCastIntegralFixedPointBool( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCastIntegralFixedPoint(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCastIntegralFixedPoint(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCastIntegralFixedPointSint8(A0, I); case PT_Uint8: return emitCastIntegralFixedPointUint8(A0, I); case PT_Sint16: return emitCastIntegralFixedPointSint16(A0, I); case PT_Uint16: return emitCastIntegralFixedPointUint16(A0, I); case PT_Sint32: return emitCastIntegralFixedPointSint32(A0, I); case PT_Uint32: return emitCastIntegralFixedPointUint32(A0, I); case PT_Sint64: return emitCastIntegralFixedPointSint64(A0, I); case PT_Uint64: return emitCastIntegralFixedPointUint64(A0, I); case PT_Bool: return emitCastIntegralFixedPointBool(A0, I); default: llvm_unreachable("invalid type: emitCastIntegralFixedPoint"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastIntegralFixedPointSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastIntegralFixedPointSint8, A0, L); } bool ByteCodeEmitter::emitCastIntegralFixedPointUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastIntegralFixedPointUint8, A0, L); } bool ByteCodeEmitter::emitCastIntegralFixedPointSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastIntegralFixedPointSint16, A0, L); } bool ByteCodeEmitter::emitCastIntegralFixedPointUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastIntegralFixedPointUint16, A0, L); } bool ByteCodeEmitter::emitCastIntegralFixedPointSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastIntegralFixedPointSint32, A0, L); } bool ByteCodeEmitter::emitCastIntegralFixedPointUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastIntegralFixedPointUint32, A0, L); } bool ByteCodeEmitter::emitCastIntegralFixedPointSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastIntegralFixedPointSint64, A0, L); } bool ByteCodeEmitter::emitCastIntegralFixedPointUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastIntegralFixedPointUint64, A0, L); } bool ByteCodeEmitter::emitCastIntegralFixedPointBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastIntegralFixedPointBool, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastIntegralFixedPointSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFixedPoint(S, OpPC, A0); } bool EvalEmitter::emitCastIntegralFixedPointUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFixedPoint(S, OpPC, A0); } bool EvalEmitter::emitCastIntegralFixedPointSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFixedPoint(S, OpPC, A0); } bool EvalEmitter::emitCastIntegralFixedPointUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFixedPoint(S, OpPC, A0); } bool EvalEmitter::emitCastIntegralFixedPointSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFixedPoint(S, OpPC, A0); } bool EvalEmitter::emitCastIntegralFixedPointUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFixedPoint(S, OpPC, A0); } bool EvalEmitter::emitCastIntegralFixedPointSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFixedPoint(S, OpPC, A0); } bool EvalEmitter::emitCastIntegralFixedPointUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFixedPoint(S, OpPC, A0); } bool EvalEmitter::emitCastIntegralFixedPointBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFixedPoint(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CastIntegralFloatingSint8, OP_CastIntegralFloatingUint8, OP_CastIntegralFloatingSint16, OP_CastIntegralFloatingUint16, OP_CastIntegralFloatingSint32, OP_CastIntegralFloatingUint32, OP_CastIntegralFloatingSint64, OP_CastIntegralFloatingUint64, OP_CastIntegralFloatingIntAP, OP_CastIntegralFloatingIntAPS, OP_CastIntegralFloatingBool, OP_CastIntegralFloatingFixedPoint, #endif #ifdef GET_INTERP case OP_CastIntegralFloatingSint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingUint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingSint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingUint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingSint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingUint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingSint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingUint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingIntAP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingIntAPS: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingBool: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } case OP_CastIntegralFloatingFixedPoint: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!CastIntegralFloating(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastIntegralFloatingSint8: Text.Op = PrintName("CastIntegralFloatingSint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingUint8: Text.Op = PrintName("CastIntegralFloatingUint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingSint16: Text.Op = PrintName("CastIntegralFloatingSint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingUint16: Text.Op = PrintName("CastIntegralFloatingUint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingSint32: Text.Op = PrintName("CastIntegralFloatingSint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingUint32: Text.Op = PrintName("CastIntegralFloatingUint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingSint64: Text.Op = PrintName("CastIntegralFloatingSint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingUint64: Text.Op = PrintName("CastIntegralFloatingUint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingIntAP: Text.Op = PrintName("CastIntegralFloatingIntAP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingIntAPS: Text.Op = PrintName("CastIntegralFloatingIntAPS"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingBool: Text.Op = PrintName("CastIntegralFloatingBool"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CastIntegralFloatingFixedPoint: Text.Op = PrintName("CastIntegralFloatingFixedPoint"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastIntegralFloatingSint8( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingUint8( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingSint16( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingUint16( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingSint32( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingUint32( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingSint64( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingUint64( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingIntAP( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingIntAPS( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingBool( const llvm::fltSemantics * , uint32_t , const SourceInfo &); bool emitCastIntegralFloatingFixedPoint( const llvm::fltSemantics * , uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCastIntegralFloating(PrimType, const llvm::fltSemantics *, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCastIntegralFloating(PrimType T0, const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCastIntegralFloatingSint8(A0, A1, I); case PT_Uint8: return emitCastIntegralFloatingUint8(A0, A1, I); case PT_Sint16: return emitCastIntegralFloatingSint16(A0, A1, I); case PT_Uint16: return emitCastIntegralFloatingUint16(A0, A1, I); case PT_Sint32: return emitCastIntegralFloatingSint32(A0, A1, I); case PT_Uint32: return emitCastIntegralFloatingUint32(A0, A1, I); case PT_Sint64: return emitCastIntegralFloatingSint64(A0, A1, I); case PT_Uint64: return emitCastIntegralFloatingUint64(A0, A1, I); case PT_IntAP: return emitCastIntegralFloatingIntAP(A0, A1, I); case PT_IntAPS: return emitCastIntegralFloatingIntAPS(A0, A1, I); case PT_Bool: return emitCastIntegralFloatingBool(A0, A1, I); case PT_FixedPoint: return emitCastIntegralFloatingFixedPoint(A0, A1, I); default: llvm_unreachable("invalid type: emitCastIntegralFloating"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastIntegralFloatingSint8( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingSint8, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingUint8( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingUint8, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingSint16( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingSint16, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingUint16( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingUint16, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingSint32( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingSint32, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingUint32( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingUint32, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingSint64( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingSint64, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingUint64( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingUint64, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingIntAP( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingIntAP, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingIntAPS( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingIntAPS, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingBool( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingBool, A0, A1, L); } bool ByteCodeEmitter::emitCastIntegralFloatingFixedPoint( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_CastIntegralFloatingFixedPoint, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastIntegralFloatingSint8( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingUint8( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingSint16( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingUint16( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingSint32( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingUint32( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingSint64( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingUint64( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingIntAP( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingIntAPS( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingBool( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } bool EvalEmitter::emitCastIntegralFloatingFixedPoint( const llvm::fltSemantics * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastIntegralFloating(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_CastMemberPtrPtr, #endif #ifdef GET_INTERP case OP_CastMemberPtrPtr: { if (!CastMemberPtrPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastMemberPtrPtr: Text.Op = PrintName("CastMemberPtrPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastMemberPtrPtr(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastMemberPtrPtr(const SourceInfo &L) { return emitOp<>(OP_CastMemberPtrPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastMemberPtrPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastMemberPtrPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CastPointerIntegralSint8, OP_CastPointerIntegralUint8, OP_CastPointerIntegralSint16, OP_CastPointerIntegralUint16, OP_CastPointerIntegralSint32, OP_CastPointerIntegralUint32, OP_CastPointerIntegralSint64, OP_CastPointerIntegralUint64, OP_CastPointerIntegralBool, #endif #ifdef GET_INTERP case OP_CastPointerIntegralSint8: { if (!CastPointerIntegral(S, OpPC)) return false; continue; } case OP_CastPointerIntegralUint8: { if (!CastPointerIntegral(S, OpPC)) return false; continue; } case OP_CastPointerIntegralSint16: { if (!CastPointerIntegral(S, OpPC)) return false; continue; } case OP_CastPointerIntegralUint16: { if (!CastPointerIntegral(S, OpPC)) return false; continue; } case OP_CastPointerIntegralSint32: { if (!CastPointerIntegral(S, OpPC)) return false; continue; } case OP_CastPointerIntegralUint32: { if (!CastPointerIntegral(S, OpPC)) return false; continue; } case OP_CastPointerIntegralSint64: { if (!CastPointerIntegral(S, OpPC)) return false; continue; } case OP_CastPointerIntegralUint64: { if (!CastPointerIntegral(S, OpPC)) return false; continue; } case OP_CastPointerIntegralBool: { if (!CastPointerIntegral(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastPointerIntegralSint8: Text.Op = PrintName("CastPointerIntegralSint8"); break; case OP_CastPointerIntegralUint8: Text.Op = PrintName("CastPointerIntegralUint8"); break; case OP_CastPointerIntegralSint16: Text.Op = PrintName("CastPointerIntegralSint16"); break; case OP_CastPointerIntegralUint16: Text.Op = PrintName("CastPointerIntegralUint16"); break; case OP_CastPointerIntegralSint32: Text.Op = PrintName("CastPointerIntegralSint32"); break; case OP_CastPointerIntegralUint32: Text.Op = PrintName("CastPointerIntegralUint32"); break; case OP_CastPointerIntegralSint64: Text.Op = PrintName("CastPointerIntegralSint64"); break; case OP_CastPointerIntegralUint64: Text.Op = PrintName("CastPointerIntegralUint64"); break; case OP_CastPointerIntegralBool: Text.Op = PrintName("CastPointerIntegralBool"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastPointerIntegralSint8(const SourceInfo &); bool emitCastPointerIntegralUint8(const SourceInfo &); bool emitCastPointerIntegralSint16(const SourceInfo &); bool emitCastPointerIntegralUint16(const SourceInfo &); bool emitCastPointerIntegralSint32(const SourceInfo &); bool emitCastPointerIntegralUint32(const SourceInfo &); bool emitCastPointerIntegralSint64(const SourceInfo &); bool emitCastPointerIntegralUint64(const SourceInfo &); bool emitCastPointerIntegralBool(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCastPointerIntegral(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCastPointerIntegral(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCastPointerIntegralSint8(I); case PT_Uint8: return emitCastPointerIntegralUint8(I); case PT_Sint16: return emitCastPointerIntegralSint16(I); case PT_Uint16: return emitCastPointerIntegralUint16(I); case PT_Sint32: return emitCastPointerIntegralSint32(I); case PT_Uint32: return emitCastPointerIntegralUint32(I); case PT_Sint64: return emitCastPointerIntegralSint64(I); case PT_Uint64: return emitCastPointerIntegralUint64(I); case PT_Bool: return emitCastPointerIntegralBool(I); default: llvm_unreachable("invalid type: emitCastPointerIntegral"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastPointerIntegralSint8(const SourceInfo &L) { return emitOp<>(OP_CastPointerIntegralSint8, L); } bool ByteCodeEmitter::emitCastPointerIntegralUint8(const SourceInfo &L) { return emitOp<>(OP_CastPointerIntegralUint8, L); } bool ByteCodeEmitter::emitCastPointerIntegralSint16(const SourceInfo &L) { return emitOp<>(OP_CastPointerIntegralSint16, L); } bool ByteCodeEmitter::emitCastPointerIntegralUint16(const SourceInfo &L) { return emitOp<>(OP_CastPointerIntegralUint16, L); } bool ByteCodeEmitter::emitCastPointerIntegralSint32(const SourceInfo &L) { return emitOp<>(OP_CastPointerIntegralSint32, L); } bool ByteCodeEmitter::emitCastPointerIntegralUint32(const SourceInfo &L) { return emitOp<>(OP_CastPointerIntegralUint32, L); } bool ByteCodeEmitter::emitCastPointerIntegralSint64(const SourceInfo &L) { return emitOp<>(OP_CastPointerIntegralSint64, L); } bool ByteCodeEmitter::emitCastPointerIntegralUint64(const SourceInfo &L) { return emitOp<>(OP_CastPointerIntegralUint64, L); } bool ByteCodeEmitter::emitCastPointerIntegralBool(const SourceInfo &L) { return emitOp<>(OP_CastPointerIntegralBool, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastPointerIntegralSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegral(S, OpPC); } bool EvalEmitter::emitCastPointerIntegralUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegral(S, OpPC); } bool EvalEmitter::emitCastPointerIntegralSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegral(S, OpPC); } bool EvalEmitter::emitCastPointerIntegralUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegral(S, OpPC); } bool EvalEmitter::emitCastPointerIntegralSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegral(S, OpPC); } bool EvalEmitter::emitCastPointerIntegralUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegral(S, OpPC); } bool EvalEmitter::emitCastPointerIntegralSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegral(S, OpPC); } bool EvalEmitter::emitCastPointerIntegralUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegral(S, OpPC); } bool EvalEmitter::emitCastPointerIntegralBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegral(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CastPointerIntegralAP, #endif #ifdef GET_INTERP case OP_CastPointerIntegralAP: { const auto V0 = ReadArg(S, PC); if (!CastPointerIntegralAP(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastPointerIntegralAP: Text.Op = PrintName("CastPointerIntegralAP"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastPointerIntegralAP( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastPointerIntegralAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastPointerIntegralAP, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastPointerIntegralAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegralAP(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CastPointerIntegralAPS, #endif #ifdef GET_INTERP case OP_CastPointerIntegralAPS: { const auto V0 = ReadArg(S, PC); if (!CastPointerIntegralAPS(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CastPointerIntegralAPS: Text.Op = PrintName("CastPointerIntegralAPS"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCastPointerIntegralAPS( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCastPointerIntegralAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_CastPointerIntegralAPS, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCastPointerIntegralAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CastPointerIntegralAPS(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CheckAllocations, #endif #ifdef GET_INTERP case OP_CheckAllocations: { if (!CheckAllocations(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckAllocations: Text.Op = PrintName("CheckAllocations"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckAllocations(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckAllocations(const SourceInfo &L) { return emitOp<>(OP_CheckAllocations, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckAllocations(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckAllocations(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CheckArraySize, #endif #ifdef GET_INTERP case OP_CheckArraySize: { const auto V0 = ReadArg(S, PC); if (!CheckArraySize(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckArraySize: Text.Op = PrintName("CheckArraySize"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckArraySize( uint64_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckArraySize( uint64_t A0, const SourceInfo &L) { return emitOp(OP_CheckArraySize, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckArraySize( uint64_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckArraySize(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CheckDecl, #endif #ifdef GET_INTERP case OP_CheckDecl: { const auto V0 = ReadArg(S, PC); if (!CheckDecl(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckDecl: Text.Op = PrintName("CheckDecl"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckDecl( const VarDecl* , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckDecl( const VarDecl* A0, const SourceInfo &L) { return emitOp(OP_CheckDecl, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckDecl( const VarDecl* A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckDecl(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CheckDestruction, #endif #ifdef GET_INTERP case OP_CheckDestruction: { if (!CheckDestruction(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckDestruction: Text.Op = PrintName("CheckDestruction"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckDestruction(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckDestruction(const SourceInfo &L) { return emitOp<>(OP_CheckDestruction, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckDestruction(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckDestruction(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CheckEnumValueSint8, OP_CheckEnumValueUint8, OP_CheckEnumValueSint16, OP_CheckEnumValueUint16, OP_CheckEnumValueSint32, OP_CheckEnumValueUint32, OP_CheckEnumValueSint64, OP_CheckEnumValueUint64, OP_CheckEnumValueBool, #endif #ifdef GET_INTERP case OP_CheckEnumValueSint8: { const auto V0 = ReadArg(S, PC); if (!CheckEnumValue(S, OpPC, V0)) return false; continue; } case OP_CheckEnumValueUint8: { const auto V0 = ReadArg(S, PC); if (!CheckEnumValue(S, OpPC, V0)) return false; continue; } case OP_CheckEnumValueSint16: { const auto V0 = ReadArg(S, PC); if (!CheckEnumValue(S, OpPC, V0)) return false; continue; } case OP_CheckEnumValueUint16: { const auto V0 = ReadArg(S, PC); if (!CheckEnumValue(S, OpPC, V0)) return false; continue; } case OP_CheckEnumValueSint32: { const auto V0 = ReadArg(S, PC); if (!CheckEnumValue(S, OpPC, V0)) return false; continue; } case OP_CheckEnumValueUint32: { const auto V0 = ReadArg(S, PC); if (!CheckEnumValue(S, OpPC, V0)) return false; continue; } case OP_CheckEnumValueSint64: { const auto V0 = ReadArg(S, PC); if (!CheckEnumValue(S, OpPC, V0)) return false; continue; } case OP_CheckEnumValueUint64: { const auto V0 = ReadArg(S, PC); if (!CheckEnumValue(S, OpPC, V0)) return false; continue; } case OP_CheckEnumValueBool: { const auto V0 = ReadArg(S, PC); if (!CheckEnumValue(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckEnumValueSint8: Text.Op = PrintName("CheckEnumValueSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckEnumValueUint8: Text.Op = PrintName("CheckEnumValueUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckEnumValueSint16: Text.Op = PrintName("CheckEnumValueSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckEnumValueUint16: Text.Op = PrintName("CheckEnumValueUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckEnumValueSint32: Text.Op = PrintName("CheckEnumValueSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckEnumValueUint32: Text.Op = PrintName("CheckEnumValueUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckEnumValueSint64: Text.Op = PrintName("CheckEnumValueSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckEnumValueUint64: Text.Op = PrintName("CheckEnumValueUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckEnumValueBool: Text.Op = PrintName("CheckEnumValueBool"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckEnumValueSint8( const EnumDecl * , const SourceInfo &); bool emitCheckEnumValueUint8( const EnumDecl * , const SourceInfo &); bool emitCheckEnumValueSint16( const EnumDecl * , const SourceInfo &); bool emitCheckEnumValueUint16( const EnumDecl * , const SourceInfo &); bool emitCheckEnumValueSint32( const EnumDecl * , const SourceInfo &); bool emitCheckEnumValueUint32( const EnumDecl * , const SourceInfo &); bool emitCheckEnumValueSint64( const EnumDecl * , const SourceInfo &); bool emitCheckEnumValueUint64( const EnumDecl * , const SourceInfo &); bool emitCheckEnumValueBool( const EnumDecl * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCheckEnumValue(PrimType, const EnumDecl *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCheckEnumValue(PrimType T0, const EnumDecl * A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCheckEnumValueSint8(A0, I); case PT_Uint8: return emitCheckEnumValueUint8(A0, I); case PT_Sint16: return emitCheckEnumValueSint16(A0, I); case PT_Uint16: return emitCheckEnumValueUint16(A0, I); case PT_Sint32: return emitCheckEnumValueSint32(A0, I); case PT_Uint32: return emitCheckEnumValueUint32(A0, I); case PT_Sint64: return emitCheckEnumValueSint64(A0, I); case PT_Uint64: return emitCheckEnumValueUint64(A0, I); case PT_Bool: return emitCheckEnumValueBool(A0, I); default: llvm_unreachable("invalid type: emitCheckEnumValue"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckEnumValueSint8( const EnumDecl * A0, const SourceInfo &L) { return emitOp(OP_CheckEnumValueSint8, A0, L); } bool ByteCodeEmitter::emitCheckEnumValueUint8( const EnumDecl * A0, const SourceInfo &L) { return emitOp(OP_CheckEnumValueUint8, A0, L); } bool ByteCodeEmitter::emitCheckEnumValueSint16( const EnumDecl * A0, const SourceInfo &L) { return emitOp(OP_CheckEnumValueSint16, A0, L); } bool ByteCodeEmitter::emitCheckEnumValueUint16( const EnumDecl * A0, const SourceInfo &L) { return emitOp(OP_CheckEnumValueUint16, A0, L); } bool ByteCodeEmitter::emitCheckEnumValueSint32( const EnumDecl * A0, const SourceInfo &L) { return emitOp(OP_CheckEnumValueSint32, A0, L); } bool ByteCodeEmitter::emitCheckEnumValueUint32( const EnumDecl * A0, const SourceInfo &L) { return emitOp(OP_CheckEnumValueUint32, A0, L); } bool ByteCodeEmitter::emitCheckEnumValueSint64( const EnumDecl * A0, const SourceInfo &L) { return emitOp(OP_CheckEnumValueSint64, A0, L); } bool ByteCodeEmitter::emitCheckEnumValueUint64( const EnumDecl * A0, const SourceInfo &L) { return emitOp(OP_CheckEnumValueUint64, A0, L); } bool ByteCodeEmitter::emitCheckEnumValueBool( const EnumDecl * A0, const SourceInfo &L) { return emitOp(OP_CheckEnumValueBool, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckEnumValueSint8( const EnumDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckEnumValue(S, OpPC, A0); } bool EvalEmitter::emitCheckEnumValueUint8( const EnumDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckEnumValue(S, OpPC, A0); } bool EvalEmitter::emitCheckEnumValueSint16( const EnumDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckEnumValue(S, OpPC, A0); } bool EvalEmitter::emitCheckEnumValueUint16( const EnumDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckEnumValue(S, OpPC, A0); } bool EvalEmitter::emitCheckEnumValueSint32( const EnumDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckEnumValue(S, OpPC, A0); } bool EvalEmitter::emitCheckEnumValueUint32( const EnumDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckEnumValue(S, OpPC, A0); } bool EvalEmitter::emitCheckEnumValueSint64( const EnumDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckEnumValue(S, OpPC, A0); } bool EvalEmitter::emitCheckEnumValueUint64( const EnumDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckEnumValue(S, OpPC, A0); } bool EvalEmitter::emitCheckEnumValueBool( const EnumDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckEnumValue(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CheckLiteralType, #endif #ifdef GET_INTERP case OP_CheckLiteralType: { const auto V0 = ReadArg(S, PC); if (!CheckLiteralType(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckLiteralType: Text.Op = PrintName("CheckLiteralType"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckLiteralType( const Type * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckLiteralType( const Type * A0, const SourceInfo &L) { return emitOp(OP_CheckLiteralType, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckLiteralType( const Type * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckLiteralType(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CheckNewTypeMismatch, #endif #ifdef GET_INTERP case OP_CheckNewTypeMismatch: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatch(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckNewTypeMismatch: Text.Op = PrintName("CheckNewTypeMismatch"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckNewTypeMismatch( const Expr * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckNewTypeMismatch( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatch, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckNewTypeMismatch( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatch(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CheckNewTypeMismatchArraySint8, OP_CheckNewTypeMismatchArrayUint8, OP_CheckNewTypeMismatchArraySint16, OP_CheckNewTypeMismatchArrayUint16, OP_CheckNewTypeMismatchArraySint32, OP_CheckNewTypeMismatchArrayUint32, OP_CheckNewTypeMismatchArraySint64, OP_CheckNewTypeMismatchArrayUint64, OP_CheckNewTypeMismatchArrayIntAP, OP_CheckNewTypeMismatchArrayIntAPS, #endif #ifdef GET_INTERP case OP_CheckNewTypeMismatchArraySint8: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } case OP_CheckNewTypeMismatchArrayUint8: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } case OP_CheckNewTypeMismatchArraySint16: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } case OP_CheckNewTypeMismatchArrayUint16: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } case OP_CheckNewTypeMismatchArraySint32: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } case OP_CheckNewTypeMismatchArrayUint32: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } case OP_CheckNewTypeMismatchArraySint64: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } case OP_CheckNewTypeMismatchArrayUint64: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } case OP_CheckNewTypeMismatchArrayIntAP: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } case OP_CheckNewTypeMismatchArrayIntAPS: { const auto V0 = ReadArg(S, PC); if (!CheckNewTypeMismatchArray(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckNewTypeMismatchArraySint8: Text.Op = PrintName("CheckNewTypeMismatchArraySint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckNewTypeMismatchArrayUint8: Text.Op = PrintName("CheckNewTypeMismatchArrayUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckNewTypeMismatchArraySint16: Text.Op = PrintName("CheckNewTypeMismatchArraySint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckNewTypeMismatchArrayUint16: Text.Op = PrintName("CheckNewTypeMismatchArrayUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckNewTypeMismatchArraySint32: Text.Op = PrintName("CheckNewTypeMismatchArraySint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckNewTypeMismatchArrayUint32: Text.Op = PrintName("CheckNewTypeMismatchArrayUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckNewTypeMismatchArraySint64: Text.Op = PrintName("CheckNewTypeMismatchArraySint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckNewTypeMismatchArrayUint64: Text.Op = PrintName("CheckNewTypeMismatchArrayUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckNewTypeMismatchArrayIntAP: Text.Op = PrintName("CheckNewTypeMismatchArrayIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_CheckNewTypeMismatchArrayIntAPS: Text.Op = PrintName("CheckNewTypeMismatchArrayIntAPS"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckNewTypeMismatchArraySint8( const Expr * , const SourceInfo &); bool emitCheckNewTypeMismatchArrayUint8( const Expr * , const SourceInfo &); bool emitCheckNewTypeMismatchArraySint16( const Expr * , const SourceInfo &); bool emitCheckNewTypeMismatchArrayUint16( const Expr * , const SourceInfo &); bool emitCheckNewTypeMismatchArraySint32( const Expr * , const SourceInfo &); bool emitCheckNewTypeMismatchArrayUint32( const Expr * , const SourceInfo &); bool emitCheckNewTypeMismatchArraySint64( const Expr * , const SourceInfo &); bool emitCheckNewTypeMismatchArrayUint64( const Expr * , const SourceInfo &); bool emitCheckNewTypeMismatchArrayIntAP( const Expr * , const SourceInfo &); bool emitCheckNewTypeMismatchArrayIntAPS( const Expr * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCheckNewTypeMismatchArray(PrimType, const Expr *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCheckNewTypeMismatchArray(PrimType T0, const Expr * A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCheckNewTypeMismatchArraySint8(A0, I); case PT_Uint8: return emitCheckNewTypeMismatchArrayUint8(A0, I); case PT_Sint16: return emitCheckNewTypeMismatchArraySint16(A0, I); case PT_Uint16: return emitCheckNewTypeMismatchArrayUint16(A0, I); case PT_Sint32: return emitCheckNewTypeMismatchArraySint32(A0, I); case PT_Uint32: return emitCheckNewTypeMismatchArrayUint32(A0, I); case PT_Sint64: return emitCheckNewTypeMismatchArraySint64(A0, I); case PT_Uint64: return emitCheckNewTypeMismatchArrayUint64(A0, I); case PT_IntAP: return emitCheckNewTypeMismatchArrayIntAP(A0, I); case PT_IntAPS: return emitCheckNewTypeMismatchArrayIntAPS(A0, I); default: llvm_unreachable("invalid type: emitCheckNewTypeMismatchArray"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint8( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArraySint8, A0, L); } bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint8( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArrayUint8, A0, L); } bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint16( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArraySint16, A0, L); } bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint16( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArrayUint16, A0, L); } bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint32( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArraySint32, A0, L); } bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint32( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArrayUint32, A0, L); } bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint64( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArraySint64, A0, L); } bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint64( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArrayUint64, A0, L); } bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayIntAP( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArrayIntAP, A0, L); } bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayIntAPS( const Expr * A0, const SourceInfo &L) { return emitOp(OP_CheckNewTypeMismatchArrayIntAPS, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckNewTypeMismatchArraySint8( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } bool EvalEmitter::emitCheckNewTypeMismatchArrayUint8( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } bool EvalEmitter::emitCheckNewTypeMismatchArraySint16( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } bool EvalEmitter::emitCheckNewTypeMismatchArrayUint16( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } bool EvalEmitter::emitCheckNewTypeMismatchArraySint32( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } bool EvalEmitter::emitCheckNewTypeMismatchArrayUint32( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } bool EvalEmitter::emitCheckNewTypeMismatchArraySint64( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } bool EvalEmitter::emitCheckNewTypeMismatchArrayUint64( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } bool EvalEmitter::emitCheckNewTypeMismatchArrayIntAP( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } bool EvalEmitter::emitCheckNewTypeMismatchArrayIntAPS( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNewTypeMismatchArray(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CheckNonNullArgPtr, OP_CheckNonNullArgMemberPtr, #endif #ifdef GET_INTERP case OP_CheckNonNullArgPtr: { if (!CheckNonNullArg(S, OpPC)) return false; continue; } case OP_CheckNonNullArgMemberPtr: { if (!CheckNonNullArg(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckNonNullArgPtr: Text.Op = PrintName("CheckNonNullArgPtr"); break; case OP_CheckNonNullArgMemberPtr: Text.Op = PrintName("CheckNonNullArgMemberPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckNonNullArgPtr(const SourceInfo &); bool emitCheckNonNullArgMemberPtr(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCheckNonNullArg(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCheckNonNullArg(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Ptr: return emitCheckNonNullArgPtr(I); case PT_MemberPtr: return emitCheckNonNullArgMemberPtr(I); default: llvm_unreachable("invalid type: emitCheckNonNullArg"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckNonNullArgPtr(const SourceInfo &L) { return emitOp<>(OP_CheckNonNullArgPtr, L); } bool ByteCodeEmitter::emitCheckNonNullArgMemberPtr(const SourceInfo &L) { return emitOp<>(OP_CheckNonNullArgMemberPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckNonNullArgPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNonNullArg(S, OpPC); } bool EvalEmitter::emitCheckNonNullArgMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNonNullArg(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CheckNull, #endif #ifdef GET_INTERP case OP_CheckNull: { if (!CheckNull(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckNull: Text.Op = PrintName("CheckNull"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckNull(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckNull(const SourceInfo &L) { return emitOp<>(OP_CheckNull, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckNull(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckNull(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CheckPseudoDtor, #endif #ifdef GET_INTERP case OP_CheckPseudoDtor: { if (!CheckPseudoDtor(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CheckPseudoDtor: Text.Op = PrintName("CheckPseudoDtor"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCheckPseudoDtor(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCheckPseudoDtor(const SourceInfo &L) { return emitOp<>(OP_CheckPseudoDtor, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCheckPseudoDtor(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CheckPseudoDtor(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_CompSint8, OP_CompUint8, OP_CompSint16, OP_CompUint16, OP_CompSint32, OP_CompUint32, OP_CompSint64, OP_CompUint64, OP_CompIntAP, OP_CompIntAPS, #endif #ifdef GET_INTERP case OP_CompSint8: { if (!Comp(S, OpPC)) return false; continue; } case OP_CompUint8: { if (!Comp(S, OpPC)) return false; continue; } case OP_CompSint16: { if (!Comp(S, OpPC)) return false; continue; } case OP_CompUint16: { if (!Comp(S, OpPC)) return false; continue; } case OP_CompSint32: { if (!Comp(S, OpPC)) return false; continue; } case OP_CompUint32: { if (!Comp(S, OpPC)) return false; continue; } case OP_CompSint64: { if (!Comp(S, OpPC)) return false; continue; } case OP_CompUint64: { if (!Comp(S, OpPC)) return false; continue; } case OP_CompIntAP: { if (!Comp(S, OpPC)) return false; continue; } case OP_CompIntAPS: { if (!Comp(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_CompSint8: Text.Op = PrintName("CompSint8"); break; case OP_CompUint8: Text.Op = PrintName("CompUint8"); break; case OP_CompSint16: Text.Op = PrintName("CompSint16"); break; case OP_CompUint16: Text.Op = PrintName("CompUint16"); break; case OP_CompSint32: Text.Op = PrintName("CompSint32"); break; case OP_CompUint32: Text.Op = PrintName("CompUint32"); break; case OP_CompSint64: Text.Op = PrintName("CompSint64"); break; case OP_CompUint64: Text.Op = PrintName("CompUint64"); break; case OP_CompIntAP: Text.Op = PrintName("CompIntAP"); break; case OP_CompIntAPS: Text.Op = PrintName("CompIntAPS"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCompSint8(const SourceInfo &); bool emitCompUint8(const SourceInfo &); bool emitCompSint16(const SourceInfo &); bool emitCompUint16(const SourceInfo &); bool emitCompSint32(const SourceInfo &); bool emitCompUint32(const SourceInfo &); bool emitCompSint64(const SourceInfo &); bool emitCompUint64(const SourceInfo &); bool emitCompIntAP(const SourceInfo &); bool emitCompIntAPS(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitComp(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitComp(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCompSint8(I); case PT_Uint8: return emitCompUint8(I); case PT_Sint16: return emitCompSint16(I); case PT_Uint16: return emitCompUint16(I); case PT_Sint32: return emitCompSint32(I); case PT_Uint32: return emitCompUint32(I); case PT_Sint64: return emitCompSint64(I); case PT_Uint64: return emitCompUint64(I); case PT_IntAP: return emitCompIntAP(I); case PT_IntAPS: return emitCompIntAPS(I); default: llvm_unreachable("invalid type: emitComp"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCompSint8(const SourceInfo &L) { return emitOp<>(OP_CompSint8, L); } bool ByteCodeEmitter::emitCompUint8(const SourceInfo &L) { return emitOp<>(OP_CompUint8, L); } bool ByteCodeEmitter::emitCompSint16(const SourceInfo &L) { return emitOp<>(OP_CompSint16, L); } bool ByteCodeEmitter::emitCompUint16(const SourceInfo &L) { return emitOp<>(OP_CompUint16, L); } bool ByteCodeEmitter::emitCompSint32(const SourceInfo &L) { return emitOp<>(OP_CompSint32, L); } bool ByteCodeEmitter::emitCompUint32(const SourceInfo &L) { return emitOp<>(OP_CompUint32, L); } bool ByteCodeEmitter::emitCompSint64(const SourceInfo &L) { return emitOp<>(OP_CompSint64, L); } bool ByteCodeEmitter::emitCompUint64(const SourceInfo &L) { return emitOp<>(OP_CompUint64, L); } bool ByteCodeEmitter::emitCompIntAP(const SourceInfo &L) { return emitOp<>(OP_CompIntAP, L); } bool ByteCodeEmitter::emitCompIntAPS(const SourceInfo &L) { return emitOp<>(OP_CompIntAPS, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCompSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } bool EvalEmitter::emitCompUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } bool EvalEmitter::emitCompSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } bool EvalEmitter::emitCompUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } bool EvalEmitter::emitCompSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } bool EvalEmitter::emitCompUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } bool EvalEmitter::emitCompSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } bool EvalEmitter::emitCompUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } bool EvalEmitter::emitCompIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } bool EvalEmitter::emitCompIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Comp(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_ConstBool, #endif #ifdef GET_INTERP case OP_ConstBool: { const auto V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstBool: Text.Op = PrintName("ConstBool"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstBool( bool , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstBool( bool A0, const SourceInfo &L) { return emitOp(OP_ConstBool, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstBool( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstFixedPoint, #endif #ifdef GET_INTERP case OP_ConstFixedPoint: { const auto &V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstFixedPoint: Text.Op = PrintName("ConstFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstFixedPoint(const FixedPoint &, const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstFixedPoint(const FixedPoint &A0, const SourceInfo &L) { return emitOp(OP_ConstFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstFixedPoint(const FixedPoint &A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstFloat, #endif #ifdef GET_INTERP case OP_ConstFloat: { const auto &V0 = ReadArg(S, PC); if (!ConstFloat(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstFloat: Text.Op = PrintName("ConstFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstFloat(const Floating &, const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstFloat(const Floating &A0, const SourceInfo &L) { return emitOp(OP_ConstFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstFloat(const Floating &A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ConstFloat(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstIntAP, #endif #ifdef GET_INTERP case OP_ConstIntAP: { const auto &V0 = ReadArg>(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstIntAP: Text.Op = PrintName("ConstIntAP"); Text.Args.push_back(printArg>(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstIntAP(const IntegralAP &, const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstIntAP(const IntegralAP &A0, const SourceInfo &L) { return emitOp>(OP_ConstIntAP, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstIntAP(const IntegralAP &A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstIntAPS, #endif #ifdef GET_INTERP case OP_ConstIntAPS: { const auto &V0 = ReadArg>(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstIntAPS: Text.Op = PrintName("ConstIntAPS"); Text.Args.push_back(printArg>(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstIntAPS(const IntegralAP &, const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstIntAPS(const IntegralAP &A0, const SourceInfo &L) { return emitOp>(OP_ConstIntAPS, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstIntAPS(const IntegralAP &A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstSint8, #endif #ifdef GET_INTERP case OP_ConstSint8: { const auto V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstSint8: Text.Op = PrintName("ConstSint8"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstSint8( int8_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstSint8( int8_t A0, const SourceInfo &L) { return emitOp(OP_ConstSint8, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstSint8( int8_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstSint16, #endif #ifdef GET_INTERP case OP_ConstSint16: { const auto V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstSint16: Text.Op = PrintName("ConstSint16"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstSint16( int16_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstSint16( int16_t A0, const SourceInfo &L) { return emitOp(OP_ConstSint16, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstSint16( int16_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstSint32, #endif #ifdef GET_INTERP case OP_ConstSint32: { const auto V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstSint32: Text.Op = PrintName("ConstSint32"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstSint32( int32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstSint32( int32_t A0, const SourceInfo &L) { return emitOp(OP_ConstSint32, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstSint32( int32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstSint64, #endif #ifdef GET_INTERP case OP_ConstSint64: { const auto V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstSint64: Text.Op = PrintName("ConstSint64"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstSint64( int64_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstSint64( int64_t A0, const SourceInfo &L) { return emitOp(OP_ConstSint64, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstSint64( int64_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstUint8, #endif #ifdef GET_INTERP case OP_ConstUint8: { const auto V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstUint8: Text.Op = PrintName("ConstUint8"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstUint8( uint8_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstUint8( uint8_t A0, const SourceInfo &L) { return emitOp(OP_ConstUint8, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstUint8( uint8_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstUint16, #endif #ifdef GET_INTERP case OP_ConstUint16: { const auto V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstUint16: Text.Op = PrintName("ConstUint16"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstUint16( uint16_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstUint16( uint16_t A0, const SourceInfo &L) { return emitOp(OP_ConstUint16, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstUint16( uint16_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstUint32, #endif #ifdef GET_INTERP case OP_ConstUint32: { const auto V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstUint32: Text.Op = PrintName("ConstUint32"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstUint32( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ConstUint32, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ConstUint64, #endif #ifdef GET_INTERP case OP_ConstUint64: { const auto V0 = ReadArg(S, PC); if (!Const(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ConstUint64: Text.Op = PrintName("ConstUint64"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitConstUint64( uint64_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitConstUint64( uint64_t A0, const SourceInfo &L) { return emitOp(OP_ConstUint64, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitConstUint64( uint64_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Const(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_CopyArraySint8, OP_CopyArrayUint8, OP_CopyArraySint16, OP_CopyArrayUint16, OP_CopyArraySint32, OP_CopyArrayUint32, OP_CopyArraySint64, OP_CopyArrayUint64, OP_CopyArrayIntAP, OP_CopyArrayIntAPS, OP_CopyArrayBool, OP_CopyArrayFixedPoint, OP_CopyArrayPtr, OP_CopyArrayMemberPtr, OP_CopyArrayFloat, #endif #ifdef GET_INTERP case OP_CopyArraySint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayUint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArraySint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayUint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArraySint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayUint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArraySint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayUint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayIntAP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayIntAPS: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayBool: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayFixedPoint: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayPtr: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayMemberPtr: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } case OP_CopyArrayFloat: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!CopyArray(S, OpPC, V0, V1, V2)) return false; continue; } #endif #ifdef GET_DISASM case OP_CopyArraySint8: Text.Op = PrintName("CopyArraySint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayUint8: Text.Op = PrintName("CopyArrayUint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArraySint16: Text.Op = PrintName("CopyArraySint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayUint16: Text.Op = PrintName("CopyArrayUint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArraySint32: Text.Op = PrintName("CopyArraySint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayUint32: Text.Op = PrintName("CopyArrayUint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArraySint64: Text.Op = PrintName("CopyArraySint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayUint64: Text.Op = PrintName("CopyArrayUint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayIntAP: Text.Op = PrintName("CopyArrayIntAP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayIntAPS: Text.Op = PrintName("CopyArrayIntAPS"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayBool: Text.Op = PrintName("CopyArrayBool"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayFixedPoint: Text.Op = PrintName("CopyArrayFixedPoint"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayPtr: Text.Op = PrintName("CopyArrayPtr"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayMemberPtr: Text.Op = PrintName("CopyArrayMemberPtr"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_CopyArrayFloat: Text.Op = PrintName("CopyArrayFloat"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitCopyArraySint8( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayUint8( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArraySint16( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayUint16( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArraySint32( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayUint32( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArraySint64( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayUint64( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayIntAP( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayIntAPS( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayBool( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayFixedPoint( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayPtr( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayMemberPtr( uint32_t , uint32_t , uint32_t , const SourceInfo &); bool emitCopyArrayFloat( uint32_t , uint32_t , uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitCopyArray(PrimType, uint32_t, uint32_t, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitCopyArray(PrimType T0, uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitCopyArraySint8(A0, A1, A2, I); case PT_Uint8: return emitCopyArrayUint8(A0, A1, A2, I); case PT_Sint16: return emitCopyArraySint16(A0, A1, A2, I); case PT_Uint16: return emitCopyArrayUint16(A0, A1, A2, I); case PT_Sint32: return emitCopyArraySint32(A0, A1, A2, I); case PT_Uint32: return emitCopyArrayUint32(A0, A1, A2, I); case PT_Sint64: return emitCopyArraySint64(A0, A1, A2, I); case PT_Uint64: return emitCopyArrayUint64(A0, A1, A2, I); case PT_IntAP: return emitCopyArrayIntAP(A0, A1, A2, I); case PT_IntAPS: return emitCopyArrayIntAPS(A0, A1, A2, I); case PT_Bool: return emitCopyArrayBool(A0, A1, A2, I); case PT_FixedPoint: return emitCopyArrayFixedPoint(A0, A1, A2, I); case PT_Ptr: return emitCopyArrayPtr(A0, A1, A2, I); case PT_MemberPtr: return emitCopyArrayMemberPtr(A0, A1, A2, I); case PT_Float: return emitCopyArrayFloat(A0, A1, A2, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitCopyArraySint8( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArraySint8, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayUint8( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayUint8, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArraySint16( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArraySint16, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayUint16( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayUint16, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArraySint32( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArraySint32, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayUint32( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayUint32, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArraySint64( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArraySint64, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayUint64( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayUint64, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayIntAP( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayIntAP, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayIntAPS( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayIntAPS, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayBool( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayBool, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayFixedPoint( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayFixedPoint, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayPtr( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayPtr, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayMemberPtr( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayMemberPtr, A0, A1, A2, L); } bool ByteCodeEmitter::emitCopyArrayFloat( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { return emitOp(OP_CopyArrayFloat, A0, A1, A2, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitCopyArraySint8( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayUint8( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArraySint16( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayUint16( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArraySint32( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayUint32( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArraySint64( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayUint64( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayIntAP( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayIntAPS( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayBool( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayFixedPoint( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayPtr( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayMemberPtr( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } bool EvalEmitter::emitCopyArrayFloat( uint32_t A0, uint32_t A1, uint32_t A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return CopyArray(S, OpPC, A0, A1, A2); } #endif #ifdef GET_OPCODE_NAMES OP_DecSint8, OP_DecUint8, OP_DecSint16, OP_DecUint16, OP_DecSint32, OP_DecUint32, OP_DecSint64, OP_DecUint64, OP_DecIntAP, OP_DecIntAPS, OP_DecBool, OP_DecFixedPoint, #endif #ifdef GET_INTERP case OP_DecSint8: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecUint8: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecSint16: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecUint16: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecSint32: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecUint32: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecSint64: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecUint64: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecIntAP: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecIntAPS: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecBool: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } case OP_DecFixedPoint: { const auto V0 = ReadArg(S, PC); if (!Dec(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_DecSint8: Text.Op = PrintName("DecSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecUint8: Text.Op = PrintName("DecUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecSint16: Text.Op = PrintName("DecSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecUint16: Text.Op = PrintName("DecUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecSint32: Text.Op = PrintName("DecSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecUint32: Text.Op = PrintName("DecUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecSint64: Text.Op = PrintName("DecSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecUint64: Text.Op = PrintName("DecUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecIntAP: Text.Op = PrintName("DecIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecIntAPS: Text.Op = PrintName("DecIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecBool: Text.Op = PrintName("DecBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecFixedPoint: Text.Op = PrintName("DecFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDecSint8( bool , const SourceInfo &); bool emitDecUint8( bool , const SourceInfo &); bool emitDecSint16( bool , const SourceInfo &); bool emitDecUint16( bool , const SourceInfo &); bool emitDecSint32( bool , const SourceInfo &); bool emitDecUint32( bool , const SourceInfo &); bool emitDecSint64( bool , const SourceInfo &); bool emitDecUint64( bool , const SourceInfo &); bool emitDecIntAP( bool , const SourceInfo &); bool emitDecIntAPS( bool , const SourceInfo &); bool emitDecBool( bool , const SourceInfo &); bool emitDecFixedPoint( bool , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitDec(PrimType, bool, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitDec(PrimType T0, bool A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitDecSint8(A0, I); case PT_Uint8: return emitDecUint8(A0, I); case PT_Sint16: return emitDecSint16(A0, I); case PT_Uint16: return emitDecUint16(A0, I); case PT_Sint32: return emitDecSint32(A0, I); case PT_Uint32: return emitDecUint32(A0, I); case PT_Sint64: return emitDecSint64(A0, I); case PT_Uint64: return emitDecUint64(A0, I); case PT_IntAP: return emitDecIntAP(A0, I); case PT_IntAPS: return emitDecIntAPS(A0, I); case PT_Bool: return emitDecBool(A0, I); case PT_FixedPoint: return emitDecFixedPoint(A0, I); default: llvm_unreachable("invalid type: emitDec"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDecSint8( bool A0, const SourceInfo &L) { return emitOp(OP_DecSint8, A0, L); } bool ByteCodeEmitter::emitDecUint8( bool A0, const SourceInfo &L) { return emitOp(OP_DecUint8, A0, L); } bool ByteCodeEmitter::emitDecSint16( bool A0, const SourceInfo &L) { return emitOp(OP_DecSint16, A0, L); } bool ByteCodeEmitter::emitDecUint16( bool A0, const SourceInfo &L) { return emitOp(OP_DecUint16, A0, L); } bool ByteCodeEmitter::emitDecSint32( bool A0, const SourceInfo &L) { return emitOp(OP_DecSint32, A0, L); } bool ByteCodeEmitter::emitDecUint32( bool A0, const SourceInfo &L) { return emitOp(OP_DecUint32, A0, L); } bool ByteCodeEmitter::emitDecSint64( bool A0, const SourceInfo &L) { return emitOp(OP_DecSint64, A0, L); } bool ByteCodeEmitter::emitDecUint64( bool A0, const SourceInfo &L) { return emitOp(OP_DecUint64, A0, L); } bool ByteCodeEmitter::emitDecIntAP( bool A0, const SourceInfo &L) { return emitOp(OP_DecIntAP, A0, L); } bool ByteCodeEmitter::emitDecIntAPS( bool A0, const SourceInfo &L) { return emitOp(OP_DecIntAPS, A0, L); } bool ByteCodeEmitter::emitDecBool( bool A0, const SourceInfo &L) { return emitOp(OP_DecBool, A0, L); } bool ByteCodeEmitter::emitDecFixedPoint( bool A0, const SourceInfo &L) { return emitOp(OP_DecFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDecSint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecUint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecSint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecUint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecSint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecUint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecSint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecUint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecIntAP( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecIntAPS( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecBool( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } bool EvalEmitter::emitDecFixedPoint( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dec(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_DecPopSint8, OP_DecPopUint8, OP_DecPopSint16, OP_DecPopUint16, OP_DecPopSint32, OP_DecPopUint32, OP_DecPopSint64, OP_DecPopUint64, OP_DecPopIntAP, OP_DecPopIntAPS, OP_DecPopBool, OP_DecPopFixedPoint, #endif #ifdef GET_INTERP case OP_DecPopSint8: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopUint8: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopSint16: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopUint16: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopSint32: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopUint32: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopSint64: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopUint64: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopIntAP: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopIntAPS: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopBool: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } case OP_DecPopFixedPoint: { const auto V0 = ReadArg(S, PC); if (!DecPop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_DecPopSint8: Text.Op = PrintName("DecPopSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopUint8: Text.Op = PrintName("DecPopUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopSint16: Text.Op = PrintName("DecPopSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopUint16: Text.Op = PrintName("DecPopUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopSint32: Text.Op = PrintName("DecPopSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopUint32: Text.Op = PrintName("DecPopUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopSint64: Text.Op = PrintName("DecPopSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopUint64: Text.Op = PrintName("DecPopUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopIntAP: Text.Op = PrintName("DecPopIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopIntAPS: Text.Op = PrintName("DecPopIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopBool: Text.Op = PrintName("DecPopBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_DecPopFixedPoint: Text.Op = PrintName("DecPopFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDecPopSint8( bool , const SourceInfo &); bool emitDecPopUint8( bool , const SourceInfo &); bool emitDecPopSint16( bool , const SourceInfo &); bool emitDecPopUint16( bool , const SourceInfo &); bool emitDecPopSint32( bool , const SourceInfo &); bool emitDecPopUint32( bool , const SourceInfo &); bool emitDecPopSint64( bool , const SourceInfo &); bool emitDecPopUint64( bool , const SourceInfo &); bool emitDecPopIntAP( bool , const SourceInfo &); bool emitDecPopIntAPS( bool , const SourceInfo &); bool emitDecPopBool( bool , const SourceInfo &); bool emitDecPopFixedPoint( bool , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitDecPop(PrimType, bool, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitDecPop(PrimType T0, bool A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitDecPopSint8(A0, I); case PT_Uint8: return emitDecPopUint8(A0, I); case PT_Sint16: return emitDecPopSint16(A0, I); case PT_Uint16: return emitDecPopUint16(A0, I); case PT_Sint32: return emitDecPopSint32(A0, I); case PT_Uint32: return emitDecPopUint32(A0, I); case PT_Sint64: return emitDecPopSint64(A0, I); case PT_Uint64: return emitDecPopUint64(A0, I); case PT_IntAP: return emitDecPopIntAP(A0, I); case PT_IntAPS: return emitDecPopIntAPS(A0, I); case PT_Bool: return emitDecPopBool(A0, I); case PT_FixedPoint: return emitDecPopFixedPoint(A0, I); default: llvm_unreachable("invalid type: emitDecPop"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDecPopSint8( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopSint8, A0, L); } bool ByteCodeEmitter::emitDecPopUint8( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopUint8, A0, L); } bool ByteCodeEmitter::emitDecPopSint16( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopSint16, A0, L); } bool ByteCodeEmitter::emitDecPopUint16( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopUint16, A0, L); } bool ByteCodeEmitter::emitDecPopSint32( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopSint32, A0, L); } bool ByteCodeEmitter::emitDecPopUint32( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopUint32, A0, L); } bool ByteCodeEmitter::emitDecPopSint64( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopSint64, A0, L); } bool ByteCodeEmitter::emitDecPopUint64( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopUint64, A0, L); } bool ByteCodeEmitter::emitDecPopIntAP( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopIntAP, A0, L); } bool ByteCodeEmitter::emitDecPopIntAPS( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopIntAPS, A0, L); } bool ByteCodeEmitter::emitDecPopBool( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopBool, A0, L); } bool ByteCodeEmitter::emitDecPopFixedPoint( bool A0, const SourceInfo &L) { return emitOp(OP_DecPopFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDecPopSint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopUint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopSint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopUint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopSint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopUint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopSint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopUint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopIntAP( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopIntAPS( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopBool( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } bool EvalEmitter::emitDecPopFixedPoint( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_DecPtr, #endif #ifdef GET_INTERP case OP_DecPtr: { if (!DecPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_DecPtr: Text.Op = PrintName("DecPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDecPtr(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDecPtr(const SourceInfo &L) { return emitOp<>(OP_DecPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDecPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_DecayPtrPtrPtr, OP_DecayPtrPtrMemberPtr, OP_DecayPtrMemberPtrPtr, OP_DecayPtrMemberPtrMemberPtr, #endif #ifdef GET_INTERP case OP_DecayPtrPtrPtr: { if (!DecayPtr(S, OpPC)) return false; continue; } case OP_DecayPtrPtrMemberPtr: { if (!DecayPtr(S, OpPC)) return false; continue; } case OP_DecayPtrMemberPtrPtr: { if (!DecayPtr(S, OpPC)) return false; continue; } case OP_DecayPtrMemberPtrMemberPtr: { if (!DecayPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_DecayPtrPtrPtr: Text.Op = PrintName("DecayPtrPtrPtr"); break; case OP_DecayPtrPtrMemberPtr: Text.Op = PrintName("DecayPtrPtrMemberPtr"); break; case OP_DecayPtrMemberPtrPtr: Text.Op = PrintName("DecayPtrMemberPtrPtr"); break; case OP_DecayPtrMemberPtrMemberPtr: Text.Op = PrintName("DecayPtrMemberPtrMemberPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDecayPtrPtrPtr(const SourceInfo &); bool emitDecayPtrPtrMemberPtr(const SourceInfo &); bool emitDecayPtrMemberPtrPtr(const SourceInfo &); bool emitDecayPtrMemberPtrMemberPtr(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitDecayPtr(PrimType, PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitDecayPtr(PrimType T0, PrimType T1, const SourceInfo &I) { switch (T0) { case PT_Ptr: switch (T1) { case PT_Ptr: return emitDecayPtrPtrPtr(I); case PT_MemberPtr: return emitDecayPtrPtrMemberPtr(I); default: llvm_unreachable("invalid type: emitDecayPtr"); } llvm_unreachable("invalid enum value"); case PT_MemberPtr: switch (T1) { case PT_Ptr: return emitDecayPtrMemberPtrPtr(I); case PT_MemberPtr: return emitDecayPtrMemberPtrMemberPtr(I); default: llvm_unreachable("invalid type: emitDecayPtr"); } llvm_unreachable("invalid enum value"); default: llvm_unreachable("invalid type: emitDecayPtr"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDecayPtrPtrPtr(const SourceInfo &L) { return emitOp<>(OP_DecayPtrPtrPtr, L); } bool ByteCodeEmitter::emitDecayPtrPtrMemberPtr(const SourceInfo &L) { return emitOp<>(OP_DecayPtrPtrMemberPtr, L); } bool ByteCodeEmitter::emitDecayPtrMemberPtrPtr(const SourceInfo &L) { return emitOp<>(OP_DecayPtrMemberPtrPtr, L); } bool ByteCodeEmitter::emitDecayPtrMemberPtrMemberPtr(const SourceInfo &L) { return emitOp<>(OP_DecayPtrMemberPtrMemberPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDecayPtrPtrPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecayPtr(S, OpPC); } bool EvalEmitter::emitDecayPtrPtrMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecayPtr(S, OpPC); } bool EvalEmitter::emitDecayPtrMemberPtrPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecayPtr(S, OpPC); } bool EvalEmitter::emitDecayPtrMemberPtrMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecayPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Decf, #endif #ifdef GET_INTERP case OP_Decf: { const auto V0 = ReadArg(S, PC); if (!Decf(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Decf: Text.Op = PrintName("Decf"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDecf( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDecf( uint32_t A0, const SourceInfo &L) { return emitOp(OP_Decf, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDecf( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Decf(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_DecfPop, #endif #ifdef GET_INTERP case OP_DecfPop: { const auto V0 = ReadArg(S, PC); if (!DecfPop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_DecfPop: Text.Op = PrintName("DecfPop"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDecfPop( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDecfPop( uint32_t A0, const SourceInfo &L) { return emitOp(OP_DecfPop, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDecfPop( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DecfPop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_Destroy, #endif #ifdef GET_INTERP case OP_Destroy: { const auto V0 = ReadArg(S, PC); if (!Destroy(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Destroy: Text.Op = PrintName("Destroy"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDestroy( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDestroy( uint32_t A0, const SourceInfo &L) { return emitOp(OP_Destroy, A0, L); } #endif #ifdef GET_OPCODE_NAMES OP_DiagTypeid, #endif #ifdef GET_INTERP case OP_DiagTypeid: { if (!DiagTypeid(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_DiagTypeid: Text.Op = PrintName("DiagTypeid"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDiagTypeid(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDiagTypeid(const SourceInfo &L) { return emitOp<>(OP_DiagTypeid, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDiagTypeid(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return DiagTypeid(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_DivSint8, OP_DivUint8, OP_DivSint16, OP_DivUint16, OP_DivSint32, OP_DivUint32, OP_DivSint64, OP_DivUint64, OP_DivIntAP, OP_DivIntAPS, OP_DivFixedPoint, #endif #ifdef GET_INTERP case OP_DivSint8: { if (!Div(S, OpPC)) return false; continue; } case OP_DivUint8: { if (!Div(S, OpPC)) return false; continue; } case OP_DivSint16: { if (!Div(S, OpPC)) return false; continue; } case OP_DivUint16: { if (!Div(S, OpPC)) return false; continue; } case OP_DivSint32: { if (!Div(S, OpPC)) return false; continue; } case OP_DivUint32: { if (!Div(S, OpPC)) return false; continue; } case OP_DivSint64: { if (!Div(S, OpPC)) return false; continue; } case OP_DivUint64: { if (!Div(S, OpPC)) return false; continue; } case OP_DivIntAP: { if (!Div(S, OpPC)) return false; continue; } case OP_DivIntAPS: { if (!Div(S, OpPC)) return false; continue; } case OP_DivFixedPoint: { if (!Div(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_DivSint8: Text.Op = PrintName("DivSint8"); break; case OP_DivUint8: Text.Op = PrintName("DivUint8"); break; case OP_DivSint16: Text.Op = PrintName("DivSint16"); break; case OP_DivUint16: Text.Op = PrintName("DivUint16"); break; case OP_DivSint32: Text.Op = PrintName("DivSint32"); break; case OP_DivUint32: Text.Op = PrintName("DivUint32"); break; case OP_DivSint64: Text.Op = PrintName("DivSint64"); break; case OP_DivUint64: Text.Op = PrintName("DivUint64"); break; case OP_DivIntAP: Text.Op = PrintName("DivIntAP"); break; case OP_DivIntAPS: Text.Op = PrintName("DivIntAPS"); break; case OP_DivFixedPoint: Text.Op = PrintName("DivFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDivSint8(const SourceInfo &); bool emitDivUint8(const SourceInfo &); bool emitDivSint16(const SourceInfo &); bool emitDivUint16(const SourceInfo &); bool emitDivSint32(const SourceInfo &); bool emitDivUint32(const SourceInfo &); bool emitDivSint64(const SourceInfo &); bool emitDivUint64(const SourceInfo &); bool emitDivIntAP(const SourceInfo &); bool emitDivIntAPS(const SourceInfo &); bool emitDivFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitDiv(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitDiv(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitDivSint8(I); case PT_Uint8: return emitDivUint8(I); case PT_Sint16: return emitDivSint16(I); case PT_Uint16: return emitDivUint16(I); case PT_Sint32: return emitDivSint32(I); case PT_Uint32: return emitDivUint32(I); case PT_Sint64: return emitDivSint64(I); case PT_Uint64: return emitDivUint64(I); case PT_IntAP: return emitDivIntAP(I); case PT_IntAPS: return emitDivIntAPS(I); case PT_FixedPoint: return emitDivFixedPoint(I); default: llvm_unreachable("invalid type: emitDiv"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDivSint8(const SourceInfo &L) { return emitOp<>(OP_DivSint8, L); } bool ByteCodeEmitter::emitDivUint8(const SourceInfo &L) { return emitOp<>(OP_DivUint8, L); } bool ByteCodeEmitter::emitDivSint16(const SourceInfo &L) { return emitOp<>(OP_DivSint16, L); } bool ByteCodeEmitter::emitDivUint16(const SourceInfo &L) { return emitOp<>(OP_DivUint16, L); } bool ByteCodeEmitter::emitDivSint32(const SourceInfo &L) { return emitOp<>(OP_DivSint32, L); } bool ByteCodeEmitter::emitDivUint32(const SourceInfo &L) { return emitOp<>(OP_DivUint32, L); } bool ByteCodeEmitter::emitDivSint64(const SourceInfo &L) { return emitOp<>(OP_DivSint64, L); } bool ByteCodeEmitter::emitDivUint64(const SourceInfo &L) { return emitOp<>(OP_DivUint64, L); } bool ByteCodeEmitter::emitDivIntAP(const SourceInfo &L) { return emitOp<>(OP_DivIntAP, L); } bool ByteCodeEmitter::emitDivIntAPS(const SourceInfo &L) { return emitOp<>(OP_DivIntAPS, L); } bool ByteCodeEmitter::emitDivFixedPoint(const SourceInfo &L) { return emitOp<>(OP_DivFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDivSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } bool EvalEmitter::emitDivFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Div(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_DivcSint8, OP_DivcUint8, OP_DivcSint16, OP_DivcUint16, OP_DivcSint32, OP_DivcUint32, OP_DivcSint64, OP_DivcUint64, OP_DivcIntAP, OP_DivcIntAPS, OP_DivcFloat, #endif #ifdef GET_INTERP case OP_DivcSint8: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcUint8: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcSint16: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcUint16: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcSint32: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcUint32: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcSint64: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcUint64: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcIntAP: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcIntAPS: { if (!Divc(S, OpPC)) return false; continue; } case OP_DivcFloat: { if (!Divc(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_DivcSint8: Text.Op = PrintName("DivcSint8"); break; case OP_DivcUint8: Text.Op = PrintName("DivcUint8"); break; case OP_DivcSint16: Text.Op = PrintName("DivcSint16"); break; case OP_DivcUint16: Text.Op = PrintName("DivcUint16"); break; case OP_DivcSint32: Text.Op = PrintName("DivcSint32"); break; case OP_DivcUint32: Text.Op = PrintName("DivcUint32"); break; case OP_DivcSint64: Text.Op = PrintName("DivcSint64"); break; case OP_DivcUint64: Text.Op = PrintName("DivcUint64"); break; case OP_DivcIntAP: Text.Op = PrintName("DivcIntAP"); break; case OP_DivcIntAPS: Text.Op = PrintName("DivcIntAPS"); break; case OP_DivcFloat: Text.Op = PrintName("DivcFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDivcSint8(const SourceInfo &); bool emitDivcUint8(const SourceInfo &); bool emitDivcSint16(const SourceInfo &); bool emitDivcUint16(const SourceInfo &); bool emitDivcSint32(const SourceInfo &); bool emitDivcUint32(const SourceInfo &); bool emitDivcSint64(const SourceInfo &); bool emitDivcUint64(const SourceInfo &); bool emitDivcIntAP(const SourceInfo &); bool emitDivcIntAPS(const SourceInfo &); bool emitDivcFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitDivc(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitDivc(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitDivcSint8(I); case PT_Uint8: return emitDivcUint8(I); case PT_Sint16: return emitDivcSint16(I); case PT_Uint16: return emitDivcUint16(I); case PT_Sint32: return emitDivcSint32(I); case PT_Uint32: return emitDivcUint32(I); case PT_Sint64: return emitDivcSint64(I); case PT_Uint64: return emitDivcUint64(I); case PT_IntAP: return emitDivcIntAP(I); case PT_IntAPS: return emitDivcIntAPS(I); case PT_Float: return emitDivcFloat(I); default: llvm_unreachable("invalid type: emitDivc"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDivcSint8(const SourceInfo &L) { return emitOp<>(OP_DivcSint8, L); } bool ByteCodeEmitter::emitDivcUint8(const SourceInfo &L) { return emitOp<>(OP_DivcUint8, L); } bool ByteCodeEmitter::emitDivcSint16(const SourceInfo &L) { return emitOp<>(OP_DivcSint16, L); } bool ByteCodeEmitter::emitDivcUint16(const SourceInfo &L) { return emitOp<>(OP_DivcUint16, L); } bool ByteCodeEmitter::emitDivcSint32(const SourceInfo &L) { return emitOp<>(OP_DivcSint32, L); } bool ByteCodeEmitter::emitDivcUint32(const SourceInfo &L) { return emitOp<>(OP_DivcUint32, L); } bool ByteCodeEmitter::emitDivcSint64(const SourceInfo &L) { return emitOp<>(OP_DivcSint64, L); } bool ByteCodeEmitter::emitDivcUint64(const SourceInfo &L) { return emitOp<>(OP_DivcUint64, L); } bool ByteCodeEmitter::emitDivcIntAP(const SourceInfo &L) { return emitOp<>(OP_DivcIntAP, L); } bool ByteCodeEmitter::emitDivcIntAPS(const SourceInfo &L) { return emitOp<>(OP_DivcIntAPS, L); } bool ByteCodeEmitter::emitDivcFloat(const SourceInfo &L) { return emitOp<>(OP_DivcFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDivcSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } bool EvalEmitter::emitDivcFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divc(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Divf, #endif #ifdef GET_INTERP case OP_Divf: { const auto V0 = ReadArg(S, PC); if (!Divf(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Divf: Text.Op = PrintName("Divf"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDivf( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDivf( uint32_t A0, const SourceInfo &L) { return emitOp(OP_Divf, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDivf( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Divf(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_Dump, #endif #ifdef GET_INTERP case OP_Dump: { if (!Dump(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_Dump: Text.Op = PrintName("Dump"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDump(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDump(const SourceInfo &L) { return emitOp<>(OP_Dump, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDump(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dump(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_DupSint8, OP_DupUint8, OP_DupSint16, OP_DupUint16, OP_DupSint32, OP_DupUint32, OP_DupSint64, OP_DupUint64, OP_DupIntAP, OP_DupIntAPS, OP_DupBool, OP_DupFixedPoint, OP_DupPtr, OP_DupMemberPtr, OP_DupFloat, #endif #ifdef GET_INTERP case OP_DupSint8: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupUint8: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupSint16: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupUint16: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupSint32: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupUint32: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupSint64: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupUint64: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupIntAP: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupIntAPS: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupBool: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupFixedPoint: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupPtr: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupMemberPtr: { if (!Dup(S, OpPC)) return false; continue; } case OP_DupFloat: { if (!Dup(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_DupSint8: Text.Op = PrintName("DupSint8"); break; case OP_DupUint8: Text.Op = PrintName("DupUint8"); break; case OP_DupSint16: Text.Op = PrintName("DupSint16"); break; case OP_DupUint16: Text.Op = PrintName("DupUint16"); break; case OP_DupSint32: Text.Op = PrintName("DupSint32"); break; case OP_DupUint32: Text.Op = PrintName("DupUint32"); break; case OP_DupSint64: Text.Op = PrintName("DupSint64"); break; case OP_DupUint64: Text.Op = PrintName("DupUint64"); break; case OP_DupIntAP: Text.Op = PrintName("DupIntAP"); break; case OP_DupIntAPS: Text.Op = PrintName("DupIntAPS"); break; case OP_DupBool: Text.Op = PrintName("DupBool"); break; case OP_DupFixedPoint: Text.Op = PrintName("DupFixedPoint"); break; case OP_DupPtr: Text.Op = PrintName("DupPtr"); break; case OP_DupMemberPtr: Text.Op = PrintName("DupMemberPtr"); break; case OP_DupFloat: Text.Op = PrintName("DupFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitDupSint8(const SourceInfo &); bool emitDupUint8(const SourceInfo &); bool emitDupSint16(const SourceInfo &); bool emitDupUint16(const SourceInfo &); bool emitDupSint32(const SourceInfo &); bool emitDupUint32(const SourceInfo &); bool emitDupSint64(const SourceInfo &); bool emitDupUint64(const SourceInfo &); bool emitDupIntAP(const SourceInfo &); bool emitDupIntAPS(const SourceInfo &); bool emitDupBool(const SourceInfo &); bool emitDupFixedPoint(const SourceInfo &); bool emitDupPtr(const SourceInfo &); bool emitDupMemberPtr(const SourceInfo &); bool emitDupFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitDup(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitDup(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitDupSint8(I); case PT_Uint8: return emitDupUint8(I); case PT_Sint16: return emitDupSint16(I); case PT_Uint16: return emitDupUint16(I); case PT_Sint32: return emitDupSint32(I); case PT_Uint32: return emitDupUint32(I); case PT_Sint64: return emitDupSint64(I); case PT_Uint64: return emitDupUint64(I); case PT_IntAP: return emitDupIntAP(I); case PT_IntAPS: return emitDupIntAPS(I); case PT_Bool: return emitDupBool(I); case PT_FixedPoint: return emitDupFixedPoint(I); case PT_Ptr: return emitDupPtr(I); case PT_MemberPtr: return emitDupMemberPtr(I); case PT_Float: return emitDupFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitDupSint8(const SourceInfo &L) { return emitOp<>(OP_DupSint8, L); } bool ByteCodeEmitter::emitDupUint8(const SourceInfo &L) { return emitOp<>(OP_DupUint8, L); } bool ByteCodeEmitter::emitDupSint16(const SourceInfo &L) { return emitOp<>(OP_DupSint16, L); } bool ByteCodeEmitter::emitDupUint16(const SourceInfo &L) { return emitOp<>(OP_DupUint16, L); } bool ByteCodeEmitter::emitDupSint32(const SourceInfo &L) { return emitOp<>(OP_DupSint32, L); } bool ByteCodeEmitter::emitDupUint32(const SourceInfo &L) { return emitOp<>(OP_DupUint32, L); } bool ByteCodeEmitter::emitDupSint64(const SourceInfo &L) { return emitOp<>(OP_DupSint64, L); } bool ByteCodeEmitter::emitDupUint64(const SourceInfo &L) { return emitOp<>(OP_DupUint64, L); } bool ByteCodeEmitter::emitDupIntAP(const SourceInfo &L) { return emitOp<>(OP_DupIntAP, L); } bool ByteCodeEmitter::emitDupIntAPS(const SourceInfo &L) { return emitOp<>(OP_DupIntAPS, L); } bool ByteCodeEmitter::emitDupBool(const SourceInfo &L) { return emitOp<>(OP_DupBool, L); } bool ByteCodeEmitter::emitDupFixedPoint(const SourceInfo &L) { return emitOp<>(OP_DupFixedPoint, L); } bool ByteCodeEmitter::emitDupPtr(const SourceInfo &L) { return emitOp<>(OP_DupPtr, L); } bool ByteCodeEmitter::emitDupMemberPtr(const SourceInfo &L) { return emitOp<>(OP_DupMemberPtr, L); } bool ByteCodeEmitter::emitDupFloat(const SourceInfo &L) { return emitOp<>(OP_DupFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitDupSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } bool EvalEmitter::emitDupFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Dup(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_EQSint8, OP_EQUint8, OP_EQSint16, OP_EQUint16, OP_EQSint32, OP_EQUint32, OP_EQSint64, OP_EQUint64, OP_EQIntAP, OP_EQIntAPS, OP_EQBool, OP_EQFixedPoint, OP_EQPtr, OP_EQMemberPtr, OP_EQFloat, #endif #ifdef GET_INTERP case OP_EQSint8: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQUint8: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQSint16: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQUint16: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQSint32: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQUint32: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQSint64: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQUint64: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQIntAP: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQIntAPS: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQBool: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQFixedPoint: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQPtr: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQMemberPtr: { if (!EQ(S, OpPC)) return false; continue; } case OP_EQFloat: { if (!EQ(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_EQSint8: Text.Op = PrintName("EQSint8"); break; case OP_EQUint8: Text.Op = PrintName("EQUint8"); break; case OP_EQSint16: Text.Op = PrintName("EQSint16"); break; case OP_EQUint16: Text.Op = PrintName("EQUint16"); break; case OP_EQSint32: Text.Op = PrintName("EQSint32"); break; case OP_EQUint32: Text.Op = PrintName("EQUint32"); break; case OP_EQSint64: Text.Op = PrintName("EQSint64"); break; case OP_EQUint64: Text.Op = PrintName("EQUint64"); break; case OP_EQIntAP: Text.Op = PrintName("EQIntAP"); break; case OP_EQIntAPS: Text.Op = PrintName("EQIntAPS"); break; case OP_EQBool: Text.Op = PrintName("EQBool"); break; case OP_EQFixedPoint: Text.Op = PrintName("EQFixedPoint"); break; case OP_EQPtr: Text.Op = PrintName("EQPtr"); break; case OP_EQMemberPtr: Text.Op = PrintName("EQMemberPtr"); break; case OP_EQFloat: Text.Op = PrintName("EQFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitEQSint8(const SourceInfo &); bool emitEQUint8(const SourceInfo &); bool emitEQSint16(const SourceInfo &); bool emitEQUint16(const SourceInfo &); bool emitEQSint32(const SourceInfo &); bool emitEQUint32(const SourceInfo &); bool emitEQSint64(const SourceInfo &); bool emitEQUint64(const SourceInfo &); bool emitEQIntAP(const SourceInfo &); bool emitEQIntAPS(const SourceInfo &); bool emitEQBool(const SourceInfo &); bool emitEQFixedPoint(const SourceInfo &); bool emitEQPtr(const SourceInfo &); bool emitEQMemberPtr(const SourceInfo &); bool emitEQFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitEQ(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitEQ(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitEQSint8(I); case PT_Uint8: return emitEQUint8(I); case PT_Sint16: return emitEQSint16(I); case PT_Uint16: return emitEQUint16(I); case PT_Sint32: return emitEQSint32(I); case PT_Uint32: return emitEQUint32(I); case PT_Sint64: return emitEQSint64(I); case PT_Uint64: return emitEQUint64(I); case PT_IntAP: return emitEQIntAP(I); case PT_IntAPS: return emitEQIntAPS(I); case PT_Bool: return emitEQBool(I); case PT_FixedPoint: return emitEQFixedPoint(I); case PT_Ptr: return emitEQPtr(I); case PT_MemberPtr: return emitEQMemberPtr(I); case PT_Float: return emitEQFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitEQSint8(const SourceInfo &L) { return emitOp<>(OP_EQSint8, L); } bool ByteCodeEmitter::emitEQUint8(const SourceInfo &L) { return emitOp<>(OP_EQUint8, L); } bool ByteCodeEmitter::emitEQSint16(const SourceInfo &L) { return emitOp<>(OP_EQSint16, L); } bool ByteCodeEmitter::emitEQUint16(const SourceInfo &L) { return emitOp<>(OP_EQUint16, L); } bool ByteCodeEmitter::emitEQSint32(const SourceInfo &L) { return emitOp<>(OP_EQSint32, L); } bool ByteCodeEmitter::emitEQUint32(const SourceInfo &L) { return emitOp<>(OP_EQUint32, L); } bool ByteCodeEmitter::emitEQSint64(const SourceInfo &L) { return emitOp<>(OP_EQSint64, L); } bool ByteCodeEmitter::emitEQUint64(const SourceInfo &L) { return emitOp<>(OP_EQUint64, L); } bool ByteCodeEmitter::emitEQIntAP(const SourceInfo &L) { return emitOp<>(OP_EQIntAP, L); } bool ByteCodeEmitter::emitEQIntAPS(const SourceInfo &L) { return emitOp<>(OP_EQIntAPS, L); } bool ByteCodeEmitter::emitEQBool(const SourceInfo &L) { return emitOp<>(OP_EQBool, L); } bool ByteCodeEmitter::emitEQFixedPoint(const SourceInfo &L) { return emitOp<>(OP_EQFixedPoint, L); } bool ByteCodeEmitter::emitEQPtr(const SourceInfo &L) { return emitOp<>(OP_EQPtr, L); } bool ByteCodeEmitter::emitEQMemberPtr(const SourceInfo &L) { return emitOp<>(OP_EQMemberPtr, L); } bool ByteCodeEmitter::emitEQFloat(const SourceInfo &L) { return emitOp<>(OP_EQFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitEQSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } bool EvalEmitter::emitEQFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EQ(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_EndLifetime, #endif #ifdef GET_INTERP case OP_EndLifetime: { if (!EndLifetime(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_EndLifetime: Text.Op = PrintName("EndLifetime"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitEndLifetime(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitEndLifetime(const SourceInfo &L) { return emitOp<>(OP_EndLifetime, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitEndLifetime(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EndLifetime(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_EndLifetimePop, #endif #ifdef GET_INTERP case OP_EndLifetimePop: { if (!EndLifetimePop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_EndLifetimePop: Text.Op = PrintName("EndLifetimePop"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitEndLifetimePop(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitEndLifetimePop(const SourceInfo &L) { return emitOp<>(OP_EndLifetimePop, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitEndLifetimePop(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EndLifetimePop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_EndSpeculation, #endif #ifdef GET_INTERP case OP_EndSpeculation: { if (!EndSpeculation(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_EndSpeculation: Text.Op = PrintName("EndSpeculation"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitEndSpeculation(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitEndSpeculation(const SourceInfo &L) { return emitOp<>(OP_EndSpeculation, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitEndSpeculation(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return EndSpeculation(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Error, #endif #ifdef GET_INTERP case OP_Error: { if (!Error(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_Error: Text.Op = PrintName("Error"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitError(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitError(const SourceInfo &L) { return emitOp<>(OP_Error, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitError(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Error(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_ExpandPtr, #endif #ifdef GET_INTERP case OP_ExpandPtr: { if (!ExpandPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_ExpandPtr: Text.Op = PrintName("ExpandPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitExpandPtr(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitExpandPtr(const SourceInfo &L) { return emitOp<>(OP_ExpandPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitExpandPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ExpandPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_FinishInit, #endif #ifdef GET_INTERP case OP_FinishInit: { if (!FinishInit(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_FinishInit: Text.Op = PrintName("FinishInit"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitFinishInit(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitFinishInit(const SourceInfo &L) { return emitOp<>(OP_FinishInit, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitFinishInit(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return FinishInit(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_FinishInitActivate, #endif #ifdef GET_INTERP case OP_FinishInitActivate: { if (!FinishInitActivate(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_FinishInitActivate: Text.Op = PrintName("FinishInitActivate"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitFinishInitActivate(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitFinishInitActivate(const SourceInfo &L) { return emitOp<>(OP_FinishInitActivate, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitFinishInitActivate(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return FinishInitActivate(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_FinishInitActivatePop, #endif #ifdef GET_INTERP case OP_FinishInitActivatePop: { if (!FinishInitActivatePop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_FinishInitActivatePop: Text.Op = PrintName("FinishInitActivatePop"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitFinishInitActivatePop(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitFinishInitActivatePop(const SourceInfo &L) { return emitOp<>(OP_FinishInitActivatePop, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitFinishInitActivatePop(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return FinishInitActivatePop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_FinishInitGlobal, #endif #ifdef GET_INTERP case OP_FinishInitGlobal: { if (!FinishInitGlobal(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_FinishInitGlobal: Text.Op = PrintName("FinishInitGlobal"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitFinishInitGlobal(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitFinishInitGlobal(const SourceInfo &L) { return emitOp<>(OP_FinishInitGlobal, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitFinishInitGlobal(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return FinishInitGlobal(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_FinishInitPop, #endif #ifdef GET_INTERP case OP_FinishInitPop: { if (!FinishInitPop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_FinishInitPop: Text.Op = PrintName("FinishInitPop"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitFinishInitPop(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitFinishInitPop(const SourceInfo &L) { return emitOp<>(OP_FinishInitPop, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitFinishInitPop(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return FinishInitPop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_FlipSint8Sint8, OP_FlipSint8Uint8, OP_FlipSint8Sint16, OP_FlipSint8Uint16, OP_FlipSint8Sint32, OP_FlipSint8Uint32, OP_FlipSint8Sint64, OP_FlipSint8Uint64, OP_FlipSint8IntAP, OP_FlipSint8IntAPS, OP_FlipSint8Bool, OP_FlipSint8FixedPoint, OP_FlipSint8Ptr, OP_FlipSint8MemberPtr, OP_FlipSint8Float, OP_FlipUint8Sint8, OP_FlipUint8Uint8, OP_FlipUint8Sint16, OP_FlipUint8Uint16, OP_FlipUint8Sint32, OP_FlipUint8Uint32, OP_FlipUint8Sint64, OP_FlipUint8Uint64, OP_FlipUint8IntAP, OP_FlipUint8IntAPS, OP_FlipUint8Bool, OP_FlipUint8FixedPoint, OP_FlipUint8Ptr, OP_FlipUint8MemberPtr, OP_FlipUint8Float, OP_FlipSint16Sint8, OP_FlipSint16Uint8, OP_FlipSint16Sint16, OP_FlipSint16Uint16, OP_FlipSint16Sint32, OP_FlipSint16Uint32, OP_FlipSint16Sint64, OP_FlipSint16Uint64, OP_FlipSint16IntAP, OP_FlipSint16IntAPS, OP_FlipSint16Bool, OP_FlipSint16FixedPoint, OP_FlipSint16Ptr, OP_FlipSint16MemberPtr, OP_FlipSint16Float, OP_FlipUint16Sint8, OP_FlipUint16Uint8, OP_FlipUint16Sint16, OP_FlipUint16Uint16, OP_FlipUint16Sint32, OP_FlipUint16Uint32, OP_FlipUint16Sint64, OP_FlipUint16Uint64, OP_FlipUint16IntAP, OP_FlipUint16IntAPS, OP_FlipUint16Bool, OP_FlipUint16FixedPoint, OP_FlipUint16Ptr, OP_FlipUint16MemberPtr, OP_FlipUint16Float, OP_FlipSint32Sint8, OP_FlipSint32Uint8, OP_FlipSint32Sint16, OP_FlipSint32Uint16, OP_FlipSint32Sint32, OP_FlipSint32Uint32, OP_FlipSint32Sint64, OP_FlipSint32Uint64, OP_FlipSint32IntAP, OP_FlipSint32IntAPS, OP_FlipSint32Bool, OP_FlipSint32FixedPoint, OP_FlipSint32Ptr, OP_FlipSint32MemberPtr, OP_FlipSint32Float, OP_FlipUint32Sint8, OP_FlipUint32Uint8, OP_FlipUint32Sint16, OP_FlipUint32Uint16, OP_FlipUint32Sint32, OP_FlipUint32Uint32, OP_FlipUint32Sint64, OP_FlipUint32Uint64, OP_FlipUint32IntAP, OP_FlipUint32IntAPS, OP_FlipUint32Bool, OP_FlipUint32FixedPoint, OP_FlipUint32Ptr, OP_FlipUint32MemberPtr, OP_FlipUint32Float, OP_FlipSint64Sint8, OP_FlipSint64Uint8, OP_FlipSint64Sint16, OP_FlipSint64Uint16, OP_FlipSint64Sint32, OP_FlipSint64Uint32, OP_FlipSint64Sint64, OP_FlipSint64Uint64, OP_FlipSint64IntAP, OP_FlipSint64IntAPS, OP_FlipSint64Bool, OP_FlipSint64FixedPoint, OP_FlipSint64Ptr, OP_FlipSint64MemberPtr, OP_FlipSint64Float, OP_FlipUint64Sint8, OP_FlipUint64Uint8, OP_FlipUint64Sint16, OP_FlipUint64Uint16, OP_FlipUint64Sint32, OP_FlipUint64Uint32, OP_FlipUint64Sint64, OP_FlipUint64Uint64, OP_FlipUint64IntAP, OP_FlipUint64IntAPS, OP_FlipUint64Bool, OP_FlipUint64FixedPoint, OP_FlipUint64Ptr, OP_FlipUint64MemberPtr, OP_FlipUint64Float, OP_FlipIntAPSint8, OP_FlipIntAPUint8, OP_FlipIntAPSint16, OP_FlipIntAPUint16, OP_FlipIntAPSint32, OP_FlipIntAPUint32, OP_FlipIntAPSint64, OP_FlipIntAPUint64, OP_FlipIntAPIntAP, OP_FlipIntAPIntAPS, OP_FlipIntAPBool, OP_FlipIntAPFixedPoint, OP_FlipIntAPPtr, OP_FlipIntAPMemberPtr, OP_FlipIntAPFloat, OP_FlipIntAPSSint8, OP_FlipIntAPSUint8, OP_FlipIntAPSSint16, OP_FlipIntAPSUint16, OP_FlipIntAPSSint32, OP_FlipIntAPSUint32, OP_FlipIntAPSSint64, OP_FlipIntAPSUint64, OP_FlipIntAPSIntAP, OP_FlipIntAPSIntAPS, OP_FlipIntAPSBool, OP_FlipIntAPSFixedPoint, OP_FlipIntAPSPtr, OP_FlipIntAPSMemberPtr, OP_FlipIntAPSFloat, OP_FlipBoolSint8, OP_FlipBoolUint8, OP_FlipBoolSint16, OP_FlipBoolUint16, OP_FlipBoolSint32, OP_FlipBoolUint32, OP_FlipBoolSint64, OP_FlipBoolUint64, OP_FlipBoolIntAP, OP_FlipBoolIntAPS, OP_FlipBoolBool, OP_FlipBoolFixedPoint, OP_FlipBoolPtr, OP_FlipBoolMemberPtr, OP_FlipBoolFloat, OP_FlipFixedPointSint8, OP_FlipFixedPointUint8, OP_FlipFixedPointSint16, OP_FlipFixedPointUint16, OP_FlipFixedPointSint32, OP_FlipFixedPointUint32, OP_FlipFixedPointSint64, OP_FlipFixedPointUint64, OP_FlipFixedPointIntAP, OP_FlipFixedPointIntAPS, OP_FlipFixedPointBool, OP_FlipFixedPointFixedPoint, OP_FlipFixedPointPtr, OP_FlipFixedPointMemberPtr, OP_FlipFixedPointFloat, OP_FlipPtrSint8, OP_FlipPtrUint8, OP_FlipPtrSint16, OP_FlipPtrUint16, OP_FlipPtrSint32, OP_FlipPtrUint32, OP_FlipPtrSint64, OP_FlipPtrUint64, OP_FlipPtrIntAP, OP_FlipPtrIntAPS, OP_FlipPtrBool, OP_FlipPtrFixedPoint, OP_FlipPtrPtr, OP_FlipPtrMemberPtr, OP_FlipPtrFloat, OP_FlipMemberPtrSint8, OP_FlipMemberPtrUint8, OP_FlipMemberPtrSint16, OP_FlipMemberPtrUint16, OP_FlipMemberPtrSint32, OP_FlipMemberPtrUint32, OP_FlipMemberPtrSint64, OP_FlipMemberPtrUint64, OP_FlipMemberPtrIntAP, OP_FlipMemberPtrIntAPS, OP_FlipMemberPtrBool, OP_FlipMemberPtrFixedPoint, OP_FlipMemberPtrPtr, OP_FlipMemberPtrMemberPtr, OP_FlipMemberPtrFloat, OP_FlipFloatSint8, OP_FlipFloatUint8, OP_FlipFloatSint16, OP_FlipFloatUint16, OP_FlipFloatSint32, OP_FlipFloatUint32, OP_FlipFloatSint64, OP_FlipFloatUint64, OP_FlipFloatIntAP, OP_FlipFloatIntAPS, OP_FlipFloatBool, OP_FlipFloatFixedPoint, OP_FlipFloatPtr, OP_FlipFloatMemberPtr, OP_FlipFloatFloat, #endif #ifdef GET_INTERP case OP_FlipSint8Sint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Uint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Sint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Uint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Sint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Uint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Sint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Uint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8IntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8IntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Bool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8FixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Ptr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8MemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint8Float: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Sint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Uint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Sint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Uint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Sint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Uint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Sint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Uint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8IntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8IntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Bool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8FixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Ptr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8MemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint8Float: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Sint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Uint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Sint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Uint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Sint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Uint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Sint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Uint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16IntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16IntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Bool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16FixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Ptr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16MemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint16Float: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Sint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Uint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Sint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Uint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Sint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Uint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Sint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Uint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16IntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16IntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Bool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16FixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Ptr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16MemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint16Float: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Sint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Uint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Sint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Uint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Sint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Uint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Sint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Uint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32IntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32IntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Bool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32FixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Ptr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32MemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint32Float: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Sint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Uint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Sint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Uint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Sint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Uint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Sint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Uint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32IntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32IntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Bool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32FixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Ptr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32MemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint32Float: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Sint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Uint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Sint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Uint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Sint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Uint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Sint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Uint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64IntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64IntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Bool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64FixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Ptr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64MemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipSint64Float: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Sint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Uint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Sint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Uint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Sint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Uint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Sint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Uint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64IntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64IntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Bool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64FixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Ptr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64MemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipUint64Float: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPUint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPUint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPUint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPUint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPIntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPIntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPBool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPFixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPMemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPFloat: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSSint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSUint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSSint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSUint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSSint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSUint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSSint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSUint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSIntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSIntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSBool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSFixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSMemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipIntAPSFloat: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolSint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolUint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolSint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolUint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolSint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolUint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolSint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolUint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolIntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolIntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolBool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolFixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolMemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipBoolFloat: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointSint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointUint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointSint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointUint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointSint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointUint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointSint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointUint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointIntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointIntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointBool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointFixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointMemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFixedPointFloat: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrSint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrUint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrSint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrUint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrSint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrUint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrSint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrUint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrIntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrIntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrBool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrFixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrMemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipPtrFloat: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrSint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrUint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrSint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrUint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrSint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrUint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrSint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrUint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrIntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrIntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrBool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrFixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrMemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipMemberPtrFloat: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatSint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatUint8: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatSint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatUint16: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatSint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatUint32: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatSint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatUint64: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatIntAP: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatIntAPS: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatBool: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatFixedPoint: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatMemberPtr: { if (!Flip(S, OpPC)) return false; continue; } case OP_FlipFloatFloat: { if (!Flip(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_FlipSint8Sint8: Text.Op = PrintName("FlipSint8Sint8"); break; case OP_FlipSint8Uint8: Text.Op = PrintName("FlipSint8Uint8"); break; case OP_FlipSint8Sint16: Text.Op = PrintName("FlipSint8Sint16"); break; case OP_FlipSint8Uint16: Text.Op = PrintName("FlipSint8Uint16"); break; case OP_FlipSint8Sint32: Text.Op = PrintName("FlipSint8Sint32"); break; case OP_FlipSint8Uint32: Text.Op = PrintName("FlipSint8Uint32"); break; case OP_FlipSint8Sint64: Text.Op = PrintName("FlipSint8Sint64"); break; case OP_FlipSint8Uint64: Text.Op = PrintName("FlipSint8Uint64"); break; case OP_FlipSint8IntAP: Text.Op = PrintName("FlipSint8IntAP"); break; case OP_FlipSint8IntAPS: Text.Op = PrintName("FlipSint8IntAPS"); break; case OP_FlipSint8Bool: Text.Op = PrintName("FlipSint8Bool"); break; case OP_FlipSint8FixedPoint: Text.Op = PrintName("FlipSint8FixedPoint"); break; case OP_FlipSint8Ptr: Text.Op = PrintName("FlipSint8Ptr"); break; case OP_FlipSint8MemberPtr: Text.Op = PrintName("FlipSint8MemberPtr"); break; case OP_FlipSint8Float: Text.Op = PrintName("FlipSint8Float"); break; case OP_FlipUint8Sint8: Text.Op = PrintName("FlipUint8Sint8"); break; case OP_FlipUint8Uint8: Text.Op = PrintName("FlipUint8Uint8"); break; case OP_FlipUint8Sint16: Text.Op = PrintName("FlipUint8Sint16"); break; case OP_FlipUint8Uint16: Text.Op = PrintName("FlipUint8Uint16"); break; case OP_FlipUint8Sint32: Text.Op = PrintName("FlipUint8Sint32"); break; case OP_FlipUint8Uint32: Text.Op = PrintName("FlipUint8Uint32"); break; case OP_FlipUint8Sint64: Text.Op = PrintName("FlipUint8Sint64"); break; case OP_FlipUint8Uint64: Text.Op = PrintName("FlipUint8Uint64"); break; case OP_FlipUint8IntAP: Text.Op = PrintName("FlipUint8IntAP"); break; case OP_FlipUint8IntAPS: Text.Op = PrintName("FlipUint8IntAPS"); break; case OP_FlipUint8Bool: Text.Op = PrintName("FlipUint8Bool"); break; case OP_FlipUint8FixedPoint: Text.Op = PrintName("FlipUint8FixedPoint"); break; case OP_FlipUint8Ptr: Text.Op = PrintName("FlipUint8Ptr"); break; case OP_FlipUint8MemberPtr: Text.Op = PrintName("FlipUint8MemberPtr"); break; case OP_FlipUint8Float: Text.Op = PrintName("FlipUint8Float"); break; case OP_FlipSint16Sint8: Text.Op = PrintName("FlipSint16Sint8"); break; case OP_FlipSint16Uint8: Text.Op = PrintName("FlipSint16Uint8"); break; case OP_FlipSint16Sint16: Text.Op = PrintName("FlipSint16Sint16"); break; case OP_FlipSint16Uint16: Text.Op = PrintName("FlipSint16Uint16"); break; case OP_FlipSint16Sint32: Text.Op = PrintName("FlipSint16Sint32"); break; case OP_FlipSint16Uint32: Text.Op = PrintName("FlipSint16Uint32"); break; case OP_FlipSint16Sint64: Text.Op = PrintName("FlipSint16Sint64"); break; case OP_FlipSint16Uint64: Text.Op = PrintName("FlipSint16Uint64"); break; case OP_FlipSint16IntAP: Text.Op = PrintName("FlipSint16IntAP"); break; case OP_FlipSint16IntAPS: Text.Op = PrintName("FlipSint16IntAPS"); break; case OP_FlipSint16Bool: Text.Op = PrintName("FlipSint16Bool"); break; case OP_FlipSint16FixedPoint: Text.Op = PrintName("FlipSint16FixedPoint"); break; case OP_FlipSint16Ptr: Text.Op = PrintName("FlipSint16Ptr"); break; case OP_FlipSint16MemberPtr: Text.Op = PrintName("FlipSint16MemberPtr"); break; case OP_FlipSint16Float: Text.Op = PrintName("FlipSint16Float"); break; case OP_FlipUint16Sint8: Text.Op = PrintName("FlipUint16Sint8"); break; case OP_FlipUint16Uint8: Text.Op = PrintName("FlipUint16Uint8"); break; case OP_FlipUint16Sint16: Text.Op = PrintName("FlipUint16Sint16"); break; case OP_FlipUint16Uint16: Text.Op = PrintName("FlipUint16Uint16"); break; case OP_FlipUint16Sint32: Text.Op = PrintName("FlipUint16Sint32"); break; case OP_FlipUint16Uint32: Text.Op = PrintName("FlipUint16Uint32"); break; case OP_FlipUint16Sint64: Text.Op = PrintName("FlipUint16Sint64"); break; case OP_FlipUint16Uint64: Text.Op = PrintName("FlipUint16Uint64"); break; case OP_FlipUint16IntAP: Text.Op = PrintName("FlipUint16IntAP"); break; case OP_FlipUint16IntAPS: Text.Op = PrintName("FlipUint16IntAPS"); break; case OP_FlipUint16Bool: Text.Op = PrintName("FlipUint16Bool"); break; case OP_FlipUint16FixedPoint: Text.Op = PrintName("FlipUint16FixedPoint"); break; case OP_FlipUint16Ptr: Text.Op = PrintName("FlipUint16Ptr"); break; case OP_FlipUint16MemberPtr: Text.Op = PrintName("FlipUint16MemberPtr"); break; case OP_FlipUint16Float: Text.Op = PrintName("FlipUint16Float"); break; case OP_FlipSint32Sint8: Text.Op = PrintName("FlipSint32Sint8"); break; case OP_FlipSint32Uint8: Text.Op = PrintName("FlipSint32Uint8"); break; case OP_FlipSint32Sint16: Text.Op = PrintName("FlipSint32Sint16"); break; case OP_FlipSint32Uint16: Text.Op = PrintName("FlipSint32Uint16"); break; case OP_FlipSint32Sint32: Text.Op = PrintName("FlipSint32Sint32"); break; case OP_FlipSint32Uint32: Text.Op = PrintName("FlipSint32Uint32"); break; case OP_FlipSint32Sint64: Text.Op = PrintName("FlipSint32Sint64"); break; case OP_FlipSint32Uint64: Text.Op = PrintName("FlipSint32Uint64"); break; case OP_FlipSint32IntAP: Text.Op = PrintName("FlipSint32IntAP"); break; case OP_FlipSint32IntAPS: Text.Op = PrintName("FlipSint32IntAPS"); break; case OP_FlipSint32Bool: Text.Op = PrintName("FlipSint32Bool"); break; case OP_FlipSint32FixedPoint: Text.Op = PrintName("FlipSint32FixedPoint"); break; case OP_FlipSint32Ptr: Text.Op = PrintName("FlipSint32Ptr"); break; case OP_FlipSint32MemberPtr: Text.Op = PrintName("FlipSint32MemberPtr"); break; case OP_FlipSint32Float: Text.Op = PrintName("FlipSint32Float"); break; case OP_FlipUint32Sint8: Text.Op = PrintName("FlipUint32Sint8"); break; case OP_FlipUint32Uint8: Text.Op = PrintName("FlipUint32Uint8"); break; case OP_FlipUint32Sint16: Text.Op = PrintName("FlipUint32Sint16"); break; case OP_FlipUint32Uint16: Text.Op = PrintName("FlipUint32Uint16"); break; case OP_FlipUint32Sint32: Text.Op = PrintName("FlipUint32Sint32"); break; case OP_FlipUint32Uint32: Text.Op = PrintName("FlipUint32Uint32"); break; case OP_FlipUint32Sint64: Text.Op = PrintName("FlipUint32Sint64"); break; case OP_FlipUint32Uint64: Text.Op = PrintName("FlipUint32Uint64"); break; case OP_FlipUint32IntAP: Text.Op = PrintName("FlipUint32IntAP"); break; case OP_FlipUint32IntAPS: Text.Op = PrintName("FlipUint32IntAPS"); break; case OP_FlipUint32Bool: Text.Op = PrintName("FlipUint32Bool"); break; case OP_FlipUint32FixedPoint: Text.Op = PrintName("FlipUint32FixedPoint"); break; case OP_FlipUint32Ptr: Text.Op = PrintName("FlipUint32Ptr"); break; case OP_FlipUint32MemberPtr: Text.Op = PrintName("FlipUint32MemberPtr"); break; case OP_FlipUint32Float: Text.Op = PrintName("FlipUint32Float"); break; case OP_FlipSint64Sint8: Text.Op = PrintName("FlipSint64Sint8"); break; case OP_FlipSint64Uint8: Text.Op = PrintName("FlipSint64Uint8"); break; case OP_FlipSint64Sint16: Text.Op = PrintName("FlipSint64Sint16"); break; case OP_FlipSint64Uint16: Text.Op = PrintName("FlipSint64Uint16"); break; case OP_FlipSint64Sint32: Text.Op = PrintName("FlipSint64Sint32"); break; case OP_FlipSint64Uint32: Text.Op = PrintName("FlipSint64Uint32"); break; case OP_FlipSint64Sint64: Text.Op = PrintName("FlipSint64Sint64"); break; case OP_FlipSint64Uint64: Text.Op = PrintName("FlipSint64Uint64"); break; case OP_FlipSint64IntAP: Text.Op = PrintName("FlipSint64IntAP"); break; case OP_FlipSint64IntAPS: Text.Op = PrintName("FlipSint64IntAPS"); break; case OP_FlipSint64Bool: Text.Op = PrintName("FlipSint64Bool"); break; case OP_FlipSint64FixedPoint: Text.Op = PrintName("FlipSint64FixedPoint"); break; case OP_FlipSint64Ptr: Text.Op = PrintName("FlipSint64Ptr"); break; case OP_FlipSint64MemberPtr: Text.Op = PrintName("FlipSint64MemberPtr"); break; case OP_FlipSint64Float: Text.Op = PrintName("FlipSint64Float"); break; case OP_FlipUint64Sint8: Text.Op = PrintName("FlipUint64Sint8"); break; case OP_FlipUint64Uint8: Text.Op = PrintName("FlipUint64Uint8"); break; case OP_FlipUint64Sint16: Text.Op = PrintName("FlipUint64Sint16"); break; case OP_FlipUint64Uint16: Text.Op = PrintName("FlipUint64Uint16"); break; case OP_FlipUint64Sint32: Text.Op = PrintName("FlipUint64Sint32"); break; case OP_FlipUint64Uint32: Text.Op = PrintName("FlipUint64Uint32"); break; case OP_FlipUint64Sint64: Text.Op = PrintName("FlipUint64Sint64"); break; case OP_FlipUint64Uint64: Text.Op = PrintName("FlipUint64Uint64"); break; case OP_FlipUint64IntAP: Text.Op = PrintName("FlipUint64IntAP"); break; case OP_FlipUint64IntAPS: Text.Op = PrintName("FlipUint64IntAPS"); break; case OP_FlipUint64Bool: Text.Op = PrintName("FlipUint64Bool"); break; case OP_FlipUint64FixedPoint: Text.Op = PrintName("FlipUint64FixedPoint"); break; case OP_FlipUint64Ptr: Text.Op = PrintName("FlipUint64Ptr"); break; case OP_FlipUint64MemberPtr: Text.Op = PrintName("FlipUint64MemberPtr"); break; case OP_FlipUint64Float: Text.Op = PrintName("FlipUint64Float"); break; case OP_FlipIntAPSint8: Text.Op = PrintName("FlipIntAPSint8"); break; case OP_FlipIntAPUint8: Text.Op = PrintName("FlipIntAPUint8"); break; case OP_FlipIntAPSint16: Text.Op = PrintName("FlipIntAPSint16"); break; case OP_FlipIntAPUint16: Text.Op = PrintName("FlipIntAPUint16"); break; case OP_FlipIntAPSint32: Text.Op = PrintName("FlipIntAPSint32"); break; case OP_FlipIntAPUint32: Text.Op = PrintName("FlipIntAPUint32"); break; case OP_FlipIntAPSint64: Text.Op = PrintName("FlipIntAPSint64"); break; case OP_FlipIntAPUint64: Text.Op = PrintName("FlipIntAPUint64"); break; case OP_FlipIntAPIntAP: Text.Op = PrintName("FlipIntAPIntAP"); break; case OP_FlipIntAPIntAPS: Text.Op = PrintName("FlipIntAPIntAPS"); break; case OP_FlipIntAPBool: Text.Op = PrintName("FlipIntAPBool"); break; case OP_FlipIntAPFixedPoint: Text.Op = PrintName("FlipIntAPFixedPoint"); break; case OP_FlipIntAPPtr: Text.Op = PrintName("FlipIntAPPtr"); break; case OP_FlipIntAPMemberPtr: Text.Op = PrintName("FlipIntAPMemberPtr"); break; case OP_FlipIntAPFloat: Text.Op = PrintName("FlipIntAPFloat"); break; case OP_FlipIntAPSSint8: Text.Op = PrintName("FlipIntAPSSint8"); break; case OP_FlipIntAPSUint8: Text.Op = PrintName("FlipIntAPSUint8"); break; case OP_FlipIntAPSSint16: Text.Op = PrintName("FlipIntAPSSint16"); break; case OP_FlipIntAPSUint16: Text.Op = PrintName("FlipIntAPSUint16"); break; case OP_FlipIntAPSSint32: Text.Op = PrintName("FlipIntAPSSint32"); break; case OP_FlipIntAPSUint32: Text.Op = PrintName("FlipIntAPSUint32"); break; case OP_FlipIntAPSSint64: Text.Op = PrintName("FlipIntAPSSint64"); break; case OP_FlipIntAPSUint64: Text.Op = PrintName("FlipIntAPSUint64"); break; case OP_FlipIntAPSIntAP: Text.Op = PrintName("FlipIntAPSIntAP"); break; case OP_FlipIntAPSIntAPS: Text.Op = PrintName("FlipIntAPSIntAPS"); break; case OP_FlipIntAPSBool: Text.Op = PrintName("FlipIntAPSBool"); break; case OP_FlipIntAPSFixedPoint: Text.Op = PrintName("FlipIntAPSFixedPoint"); break; case OP_FlipIntAPSPtr: Text.Op = PrintName("FlipIntAPSPtr"); break; case OP_FlipIntAPSMemberPtr: Text.Op = PrintName("FlipIntAPSMemberPtr"); break; case OP_FlipIntAPSFloat: Text.Op = PrintName("FlipIntAPSFloat"); break; case OP_FlipBoolSint8: Text.Op = PrintName("FlipBoolSint8"); break; case OP_FlipBoolUint8: Text.Op = PrintName("FlipBoolUint8"); break; case OP_FlipBoolSint16: Text.Op = PrintName("FlipBoolSint16"); break; case OP_FlipBoolUint16: Text.Op = PrintName("FlipBoolUint16"); break; case OP_FlipBoolSint32: Text.Op = PrintName("FlipBoolSint32"); break; case OP_FlipBoolUint32: Text.Op = PrintName("FlipBoolUint32"); break; case OP_FlipBoolSint64: Text.Op = PrintName("FlipBoolSint64"); break; case OP_FlipBoolUint64: Text.Op = PrintName("FlipBoolUint64"); break; case OP_FlipBoolIntAP: Text.Op = PrintName("FlipBoolIntAP"); break; case OP_FlipBoolIntAPS: Text.Op = PrintName("FlipBoolIntAPS"); break; case OP_FlipBoolBool: Text.Op = PrintName("FlipBoolBool"); break; case OP_FlipBoolFixedPoint: Text.Op = PrintName("FlipBoolFixedPoint"); break; case OP_FlipBoolPtr: Text.Op = PrintName("FlipBoolPtr"); break; case OP_FlipBoolMemberPtr: Text.Op = PrintName("FlipBoolMemberPtr"); break; case OP_FlipBoolFloat: Text.Op = PrintName("FlipBoolFloat"); break; case OP_FlipFixedPointSint8: Text.Op = PrintName("FlipFixedPointSint8"); break; case OP_FlipFixedPointUint8: Text.Op = PrintName("FlipFixedPointUint8"); break; case OP_FlipFixedPointSint16: Text.Op = PrintName("FlipFixedPointSint16"); break; case OP_FlipFixedPointUint16: Text.Op = PrintName("FlipFixedPointUint16"); break; case OP_FlipFixedPointSint32: Text.Op = PrintName("FlipFixedPointSint32"); break; case OP_FlipFixedPointUint32: Text.Op = PrintName("FlipFixedPointUint32"); break; case OP_FlipFixedPointSint64: Text.Op = PrintName("FlipFixedPointSint64"); break; case OP_FlipFixedPointUint64: Text.Op = PrintName("FlipFixedPointUint64"); break; case OP_FlipFixedPointIntAP: Text.Op = PrintName("FlipFixedPointIntAP"); break; case OP_FlipFixedPointIntAPS: Text.Op = PrintName("FlipFixedPointIntAPS"); break; case OP_FlipFixedPointBool: Text.Op = PrintName("FlipFixedPointBool"); break; case OP_FlipFixedPointFixedPoint: Text.Op = PrintName("FlipFixedPointFixedPoint"); break; case OP_FlipFixedPointPtr: Text.Op = PrintName("FlipFixedPointPtr"); break; case OP_FlipFixedPointMemberPtr: Text.Op = PrintName("FlipFixedPointMemberPtr"); break; case OP_FlipFixedPointFloat: Text.Op = PrintName("FlipFixedPointFloat"); break; case OP_FlipPtrSint8: Text.Op = PrintName("FlipPtrSint8"); break; case OP_FlipPtrUint8: Text.Op = PrintName("FlipPtrUint8"); break; case OP_FlipPtrSint16: Text.Op = PrintName("FlipPtrSint16"); break; case OP_FlipPtrUint16: Text.Op = PrintName("FlipPtrUint16"); break; case OP_FlipPtrSint32: Text.Op = PrintName("FlipPtrSint32"); break; case OP_FlipPtrUint32: Text.Op = PrintName("FlipPtrUint32"); break; case OP_FlipPtrSint64: Text.Op = PrintName("FlipPtrSint64"); break; case OP_FlipPtrUint64: Text.Op = PrintName("FlipPtrUint64"); break; case OP_FlipPtrIntAP: Text.Op = PrintName("FlipPtrIntAP"); break; case OP_FlipPtrIntAPS: Text.Op = PrintName("FlipPtrIntAPS"); break; case OP_FlipPtrBool: Text.Op = PrintName("FlipPtrBool"); break; case OP_FlipPtrFixedPoint: Text.Op = PrintName("FlipPtrFixedPoint"); break; case OP_FlipPtrPtr: Text.Op = PrintName("FlipPtrPtr"); break; case OP_FlipPtrMemberPtr: Text.Op = PrintName("FlipPtrMemberPtr"); break; case OP_FlipPtrFloat: Text.Op = PrintName("FlipPtrFloat"); break; case OP_FlipMemberPtrSint8: Text.Op = PrintName("FlipMemberPtrSint8"); break; case OP_FlipMemberPtrUint8: Text.Op = PrintName("FlipMemberPtrUint8"); break; case OP_FlipMemberPtrSint16: Text.Op = PrintName("FlipMemberPtrSint16"); break; case OP_FlipMemberPtrUint16: Text.Op = PrintName("FlipMemberPtrUint16"); break; case OP_FlipMemberPtrSint32: Text.Op = PrintName("FlipMemberPtrSint32"); break; case OP_FlipMemberPtrUint32: Text.Op = PrintName("FlipMemberPtrUint32"); break; case OP_FlipMemberPtrSint64: Text.Op = PrintName("FlipMemberPtrSint64"); break; case OP_FlipMemberPtrUint64: Text.Op = PrintName("FlipMemberPtrUint64"); break; case OP_FlipMemberPtrIntAP: Text.Op = PrintName("FlipMemberPtrIntAP"); break; case OP_FlipMemberPtrIntAPS: Text.Op = PrintName("FlipMemberPtrIntAPS"); break; case OP_FlipMemberPtrBool: Text.Op = PrintName("FlipMemberPtrBool"); break; case OP_FlipMemberPtrFixedPoint: Text.Op = PrintName("FlipMemberPtrFixedPoint"); break; case OP_FlipMemberPtrPtr: Text.Op = PrintName("FlipMemberPtrPtr"); break; case OP_FlipMemberPtrMemberPtr: Text.Op = PrintName("FlipMemberPtrMemberPtr"); break; case OP_FlipMemberPtrFloat: Text.Op = PrintName("FlipMemberPtrFloat"); break; case OP_FlipFloatSint8: Text.Op = PrintName("FlipFloatSint8"); break; case OP_FlipFloatUint8: Text.Op = PrintName("FlipFloatUint8"); break; case OP_FlipFloatSint16: Text.Op = PrintName("FlipFloatSint16"); break; case OP_FlipFloatUint16: Text.Op = PrintName("FlipFloatUint16"); break; case OP_FlipFloatSint32: Text.Op = PrintName("FlipFloatSint32"); break; case OP_FlipFloatUint32: Text.Op = PrintName("FlipFloatUint32"); break; case OP_FlipFloatSint64: Text.Op = PrintName("FlipFloatSint64"); break; case OP_FlipFloatUint64: Text.Op = PrintName("FlipFloatUint64"); break; case OP_FlipFloatIntAP: Text.Op = PrintName("FlipFloatIntAP"); break; case OP_FlipFloatIntAPS: Text.Op = PrintName("FlipFloatIntAPS"); break; case OP_FlipFloatBool: Text.Op = PrintName("FlipFloatBool"); break; case OP_FlipFloatFixedPoint: Text.Op = PrintName("FlipFloatFixedPoint"); break; case OP_FlipFloatPtr: Text.Op = PrintName("FlipFloatPtr"); break; case OP_FlipFloatMemberPtr: Text.Op = PrintName("FlipFloatMemberPtr"); break; case OP_FlipFloatFloat: Text.Op = PrintName("FlipFloatFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitFlipSint8Sint8(const SourceInfo &); bool emitFlipSint8Uint8(const SourceInfo &); bool emitFlipSint8Sint16(const SourceInfo &); bool emitFlipSint8Uint16(const SourceInfo &); bool emitFlipSint8Sint32(const SourceInfo &); bool emitFlipSint8Uint32(const SourceInfo &); bool emitFlipSint8Sint64(const SourceInfo &); bool emitFlipSint8Uint64(const SourceInfo &); bool emitFlipSint8IntAP(const SourceInfo &); bool emitFlipSint8IntAPS(const SourceInfo &); bool emitFlipSint8Bool(const SourceInfo &); bool emitFlipSint8FixedPoint(const SourceInfo &); bool emitFlipSint8Ptr(const SourceInfo &); bool emitFlipSint8MemberPtr(const SourceInfo &); bool emitFlipSint8Float(const SourceInfo &); bool emitFlipUint8Sint8(const SourceInfo &); bool emitFlipUint8Uint8(const SourceInfo &); bool emitFlipUint8Sint16(const SourceInfo &); bool emitFlipUint8Uint16(const SourceInfo &); bool emitFlipUint8Sint32(const SourceInfo &); bool emitFlipUint8Uint32(const SourceInfo &); bool emitFlipUint8Sint64(const SourceInfo &); bool emitFlipUint8Uint64(const SourceInfo &); bool emitFlipUint8IntAP(const SourceInfo &); bool emitFlipUint8IntAPS(const SourceInfo &); bool emitFlipUint8Bool(const SourceInfo &); bool emitFlipUint8FixedPoint(const SourceInfo &); bool emitFlipUint8Ptr(const SourceInfo &); bool emitFlipUint8MemberPtr(const SourceInfo &); bool emitFlipUint8Float(const SourceInfo &); bool emitFlipSint16Sint8(const SourceInfo &); bool emitFlipSint16Uint8(const SourceInfo &); bool emitFlipSint16Sint16(const SourceInfo &); bool emitFlipSint16Uint16(const SourceInfo &); bool emitFlipSint16Sint32(const SourceInfo &); bool emitFlipSint16Uint32(const SourceInfo &); bool emitFlipSint16Sint64(const SourceInfo &); bool emitFlipSint16Uint64(const SourceInfo &); bool emitFlipSint16IntAP(const SourceInfo &); bool emitFlipSint16IntAPS(const SourceInfo &); bool emitFlipSint16Bool(const SourceInfo &); bool emitFlipSint16FixedPoint(const SourceInfo &); bool emitFlipSint16Ptr(const SourceInfo &); bool emitFlipSint16MemberPtr(const SourceInfo &); bool emitFlipSint16Float(const SourceInfo &); bool emitFlipUint16Sint8(const SourceInfo &); bool emitFlipUint16Uint8(const SourceInfo &); bool emitFlipUint16Sint16(const SourceInfo &); bool emitFlipUint16Uint16(const SourceInfo &); bool emitFlipUint16Sint32(const SourceInfo &); bool emitFlipUint16Uint32(const SourceInfo &); bool emitFlipUint16Sint64(const SourceInfo &); bool emitFlipUint16Uint64(const SourceInfo &); bool emitFlipUint16IntAP(const SourceInfo &); bool emitFlipUint16IntAPS(const SourceInfo &); bool emitFlipUint16Bool(const SourceInfo &); bool emitFlipUint16FixedPoint(const SourceInfo &); bool emitFlipUint16Ptr(const SourceInfo &); bool emitFlipUint16MemberPtr(const SourceInfo &); bool emitFlipUint16Float(const SourceInfo &); bool emitFlipSint32Sint8(const SourceInfo &); bool emitFlipSint32Uint8(const SourceInfo &); bool emitFlipSint32Sint16(const SourceInfo &); bool emitFlipSint32Uint16(const SourceInfo &); bool emitFlipSint32Sint32(const SourceInfo &); bool emitFlipSint32Uint32(const SourceInfo &); bool emitFlipSint32Sint64(const SourceInfo &); bool emitFlipSint32Uint64(const SourceInfo &); bool emitFlipSint32IntAP(const SourceInfo &); bool emitFlipSint32IntAPS(const SourceInfo &); bool emitFlipSint32Bool(const SourceInfo &); bool emitFlipSint32FixedPoint(const SourceInfo &); bool emitFlipSint32Ptr(const SourceInfo &); bool emitFlipSint32MemberPtr(const SourceInfo &); bool emitFlipSint32Float(const SourceInfo &); bool emitFlipUint32Sint8(const SourceInfo &); bool emitFlipUint32Uint8(const SourceInfo &); bool emitFlipUint32Sint16(const SourceInfo &); bool emitFlipUint32Uint16(const SourceInfo &); bool emitFlipUint32Sint32(const SourceInfo &); bool emitFlipUint32Uint32(const SourceInfo &); bool emitFlipUint32Sint64(const SourceInfo &); bool emitFlipUint32Uint64(const SourceInfo &); bool emitFlipUint32IntAP(const SourceInfo &); bool emitFlipUint32IntAPS(const SourceInfo &); bool emitFlipUint32Bool(const SourceInfo &); bool emitFlipUint32FixedPoint(const SourceInfo &); bool emitFlipUint32Ptr(const SourceInfo &); bool emitFlipUint32MemberPtr(const SourceInfo &); bool emitFlipUint32Float(const SourceInfo &); bool emitFlipSint64Sint8(const SourceInfo &); bool emitFlipSint64Uint8(const SourceInfo &); bool emitFlipSint64Sint16(const SourceInfo &); bool emitFlipSint64Uint16(const SourceInfo &); bool emitFlipSint64Sint32(const SourceInfo &); bool emitFlipSint64Uint32(const SourceInfo &); bool emitFlipSint64Sint64(const SourceInfo &); bool emitFlipSint64Uint64(const SourceInfo &); bool emitFlipSint64IntAP(const SourceInfo &); bool emitFlipSint64IntAPS(const SourceInfo &); bool emitFlipSint64Bool(const SourceInfo &); bool emitFlipSint64FixedPoint(const SourceInfo &); bool emitFlipSint64Ptr(const SourceInfo &); bool emitFlipSint64MemberPtr(const SourceInfo &); bool emitFlipSint64Float(const SourceInfo &); bool emitFlipUint64Sint8(const SourceInfo &); bool emitFlipUint64Uint8(const SourceInfo &); bool emitFlipUint64Sint16(const SourceInfo &); bool emitFlipUint64Uint16(const SourceInfo &); bool emitFlipUint64Sint32(const SourceInfo &); bool emitFlipUint64Uint32(const SourceInfo &); bool emitFlipUint64Sint64(const SourceInfo &); bool emitFlipUint64Uint64(const SourceInfo &); bool emitFlipUint64IntAP(const SourceInfo &); bool emitFlipUint64IntAPS(const SourceInfo &); bool emitFlipUint64Bool(const SourceInfo &); bool emitFlipUint64FixedPoint(const SourceInfo &); bool emitFlipUint64Ptr(const SourceInfo &); bool emitFlipUint64MemberPtr(const SourceInfo &); bool emitFlipUint64Float(const SourceInfo &); bool emitFlipIntAPSint8(const SourceInfo &); bool emitFlipIntAPUint8(const SourceInfo &); bool emitFlipIntAPSint16(const SourceInfo &); bool emitFlipIntAPUint16(const SourceInfo &); bool emitFlipIntAPSint32(const SourceInfo &); bool emitFlipIntAPUint32(const SourceInfo &); bool emitFlipIntAPSint64(const SourceInfo &); bool emitFlipIntAPUint64(const SourceInfo &); bool emitFlipIntAPIntAP(const SourceInfo &); bool emitFlipIntAPIntAPS(const SourceInfo &); bool emitFlipIntAPBool(const SourceInfo &); bool emitFlipIntAPFixedPoint(const SourceInfo &); bool emitFlipIntAPPtr(const SourceInfo &); bool emitFlipIntAPMemberPtr(const SourceInfo &); bool emitFlipIntAPFloat(const SourceInfo &); bool emitFlipIntAPSSint8(const SourceInfo &); bool emitFlipIntAPSUint8(const SourceInfo &); bool emitFlipIntAPSSint16(const SourceInfo &); bool emitFlipIntAPSUint16(const SourceInfo &); bool emitFlipIntAPSSint32(const SourceInfo &); bool emitFlipIntAPSUint32(const SourceInfo &); bool emitFlipIntAPSSint64(const SourceInfo &); bool emitFlipIntAPSUint64(const SourceInfo &); bool emitFlipIntAPSIntAP(const SourceInfo &); bool emitFlipIntAPSIntAPS(const SourceInfo &); bool emitFlipIntAPSBool(const SourceInfo &); bool emitFlipIntAPSFixedPoint(const SourceInfo &); bool emitFlipIntAPSPtr(const SourceInfo &); bool emitFlipIntAPSMemberPtr(const SourceInfo &); bool emitFlipIntAPSFloat(const SourceInfo &); bool emitFlipBoolSint8(const SourceInfo &); bool emitFlipBoolUint8(const SourceInfo &); bool emitFlipBoolSint16(const SourceInfo &); bool emitFlipBoolUint16(const SourceInfo &); bool emitFlipBoolSint32(const SourceInfo &); bool emitFlipBoolUint32(const SourceInfo &); bool emitFlipBoolSint64(const SourceInfo &); bool emitFlipBoolUint64(const SourceInfo &); bool emitFlipBoolIntAP(const SourceInfo &); bool emitFlipBoolIntAPS(const SourceInfo &); bool emitFlipBoolBool(const SourceInfo &); bool emitFlipBoolFixedPoint(const SourceInfo &); bool emitFlipBoolPtr(const SourceInfo &); bool emitFlipBoolMemberPtr(const SourceInfo &); bool emitFlipBoolFloat(const SourceInfo &); bool emitFlipFixedPointSint8(const SourceInfo &); bool emitFlipFixedPointUint8(const SourceInfo &); bool emitFlipFixedPointSint16(const SourceInfo &); bool emitFlipFixedPointUint16(const SourceInfo &); bool emitFlipFixedPointSint32(const SourceInfo &); bool emitFlipFixedPointUint32(const SourceInfo &); bool emitFlipFixedPointSint64(const SourceInfo &); bool emitFlipFixedPointUint64(const SourceInfo &); bool emitFlipFixedPointIntAP(const SourceInfo &); bool emitFlipFixedPointIntAPS(const SourceInfo &); bool emitFlipFixedPointBool(const SourceInfo &); bool emitFlipFixedPointFixedPoint(const SourceInfo &); bool emitFlipFixedPointPtr(const SourceInfo &); bool emitFlipFixedPointMemberPtr(const SourceInfo &); bool emitFlipFixedPointFloat(const SourceInfo &); bool emitFlipPtrSint8(const SourceInfo &); bool emitFlipPtrUint8(const SourceInfo &); bool emitFlipPtrSint16(const SourceInfo &); bool emitFlipPtrUint16(const SourceInfo &); bool emitFlipPtrSint32(const SourceInfo &); bool emitFlipPtrUint32(const SourceInfo &); bool emitFlipPtrSint64(const SourceInfo &); bool emitFlipPtrUint64(const SourceInfo &); bool emitFlipPtrIntAP(const SourceInfo &); bool emitFlipPtrIntAPS(const SourceInfo &); bool emitFlipPtrBool(const SourceInfo &); bool emitFlipPtrFixedPoint(const SourceInfo &); bool emitFlipPtrPtr(const SourceInfo &); bool emitFlipPtrMemberPtr(const SourceInfo &); bool emitFlipPtrFloat(const SourceInfo &); bool emitFlipMemberPtrSint8(const SourceInfo &); bool emitFlipMemberPtrUint8(const SourceInfo &); bool emitFlipMemberPtrSint16(const SourceInfo &); bool emitFlipMemberPtrUint16(const SourceInfo &); bool emitFlipMemberPtrSint32(const SourceInfo &); bool emitFlipMemberPtrUint32(const SourceInfo &); bool emitFlipMemberPtrSint64(const SourceInfo &); bool emitFlipMemberPtrUint64(const SourceInfo &); bool emitFlipMemberPtrIntAP(const SourceInfo &); bool emitFlipMemberPtrIntAPS(const SourceInfo &); bool emitFlipMemberPtrBool(const SourceInfo &); bool emitFlipMemberPtrFixedPoint(const SourceInfo &); bool emitFlipMemberPtrPtr(const SourceInfo &); bool emitFlipMemberPtrMemberPtr(const SourceInfo &); bool emitFlipMemberPtrFloat(const SourceInfo &); bool emitFlipFloatSint8(const SourceInfo &); bool emitFlipFloatUint8(const SourceInfo &); bool emitFlipFloatSint16(const SourceInfo &); bool emitFlipFloatUint16(const SourceInfo &); bool emitFlipFloatSint32(const SourceInfo &); bool emitFlipFloatUint32(const SourceInfo &); bool emitFlipFloatSint64(const SourceInfo &); bool emitFlipFloatUint64(const SourceInfo &); bool emitFlipFloatIntAP(const SourceInfo &); bool emitFlipFloatIntAPS(const SourceInfo &); bool emitFlipFloatBool(const SourceInfo &); bool emitFlipFloatFixedPoint(const SourceInfo &); bool emitFlipFloatPtr(const SourceInfo &); bool emitFlipFloatMemberPtr(const SourceInfo &); bool emitFlipFloatFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitFlip(PrimType, PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitFlip(PrimType T0, PrimType T1, const SourceInfo &I) { switch (T0) { case PT_Sint8: switch (T1) { case PT_Sint8: return emitFlipSint8Sint8(I); case PT_Uint8: return emitFlipSint8Uint8(I); case PT_Sint16: return emitFlipSint8Sint16(I); case PT_Uint16: return emitFlipSint8Uint16(I); case PT_Sint32: return emitFlipSint8Sint32(I); case PT_Uint32: return emitFlipSint8Uint32(I); case PT_Sint64: return emitFlipSint8Sint64(I); case PT_Uint64: return emitFlipSint8Uint64(I); case PT_IntAP: return emitFlipSint8IntAP(I); case PT_IntAPS: return emitFlipSint8IntAPS(I); case PT_Bool: return emitFlipSint8Bool(I); case PT_FixedPoint: return emitFlipSint8FixedPoint(I); case PT_Ptr: return emitFlipSint8Ptr(I); case PT_MemberPtr: return emitFlipSint8MemberPtr(I); case PT_Float: return emitFlipSint8Float(I); } llvm_unreachable("invalid enum value"); case PT_Uint8: switch (T1) { case PT_Sint8: return emitFlipUint8Sint8(I); case PT_Uint8: return emitFlipUint8Uint8(I); case PT_Sint16: return emitFlipUint8Sint16(I); case PT_Uint16: return emitFlipUint8Uint16(I); case PT_Sint32: return emitFlipUint8Sint32(I); case PT_Uint32: return emitFlipUint8Uint32(I); case PT_Sint64: return emitFlipUint8Sint64(I); case PT_Uint64: return emitFlipUint8Uint64(I); case PT_IntAP: return emitFlipUint8IntAP(I); case PT_IntAPS: return emitFlipUint8IntAPS(I); case PT_Bool: return emitFlipUint8Bool(I); case PT_FixedPoint: return emitFlipUint8FixedPoint(I); case PT_Ptr: return emitFlipUint8Ptr(I); case PT_MemberPtr: return emitFlipUint8MemberPtr(I); case PT_Float: return emitFlipUint8Float(I); } llvm_unreachable("invalid enum value"); case PT_Sint16: switch (T1) { case PT_Sint8: return emitFlipSint16Sint8(I); case PT_Uint8: return emitFlipSint16Uint8(I); case PT_Sint16: return emitFlipSint16Sint16(I); case PT_Uint16: return emitFlipSint16Uint16(I); case PT_Sint32: return emitFlipSint16Sint32(I); case PT_Uint32: return emitFlipSint16Uint32(I); case PT_Sint64: return emitFlipSint16Sint64(I); case PT_Uint64: return emitFlipSint16Uint64(I); case PT_IntAP: return emitFlipSint16IntAP(I); case PT_IntAPS: return emitFlipSint16IntAPS(I); case PT_Bool: return emitFlipSint16Bool(I); case PT_FixedPoint: return emitFlipSint16FixedPoint(I); case PT_Ptr: return emitFlipSint16Ptr(I); case PT_MemberPtr: return emitFlipSint16MemberPtr(I); case PT_Float: return emitFlipSint16Float(I); } llvm_unreachable("invalid enum value"); case PT_Uint16: switch (T1) { case PT_Sint8: return emitFlipUint16Sint8(I); case PT_Uint8: return emitFlipUint16Uint8(I); case PT_Sint16: return emitFlipUint16Sint16(I); case PT_Uint16: return emitFlipUint16Uint16(I); case PT_Sint32: return emitFlipUint16Sint32(I); case PT_Uint32: return emitFlipUint16Uint32(I); case PT_Sint64: return emitFlipUint16Sint64(I); case PT_Uint64: return emitFlipUint16Uint64(I); case PT_IntAP: return emitFlipUint16IntAP(I); case PT_IntAPS: return emitFlipUint16IntAPS(I); case PT_Bool: return emitFlipUint16Bool(I); case PT_FixedPoint: return emitFlipUint16FixedPoint(I); case PT_Ptr: return emitFlipUint16Ptr(I); case PT_MemberPtr: return emitFlipUint16MemberPtr(I); case PT_Float: return emitFlipUint16Float(I); } llvm_unreachable("invalid enum value"); case PT_Sint32: switch (T1) { case PT_Sint8: return emitFlipSint32Sint8(I); case PT_Uint8: return emitFlipSint32Uint8(I); case PT_Sint16: return emitFlipSint32Sint16(I); case PT_Uint16: return emitFlipSint32Uint16(I); case PT_Sint32: return emitFlipSint32Sint32(I); case PT_Uint32: return emitFlipSint32Uint32(I); case PT_Sint64: return emitFlipSint32Sint64(I); case PT_Uint64: return emitFlipSint32Uint64(I); case PT_IntAP: return emitFlipSint32IntAP(I); case PT_IntAPS: return emitFlipSint32IntAPS(I); case PT_Bool: return emitFlipSint32Bool(I); case PT_FixedPoint: return emitFlipSint32FixedPoint(I); case PT_Ptr: return emitFlipSint32Ptr(I); case PT_MemberPtr: return emitFlipSint32MemberPtr(I); case PT_Float: return emitFlipSint32Float(I); } llvm_unreachable("invalid enum value"); case PT_Uint32: switch (T1) { case PT_Sint8: return emitFlipUint32Sint8(I); case PT_Uint8: return emitFlipUint32Uint8(I); case PT_Sint16: return emitFlipUint32Sint16(I); case PT_Uint16: return emitFlipUint32Uint16(I); case PT_Sint32: return emitFlipUint32Sint32(I); case PT_Uint32: return emitFlipUint32Uint32(I); case PT_Sint64: return emitFlipUint32Sint64(I); case PT_Uint64: return emitFlipUint32Uint64(I); case PT_IntAP: return emitFlipUint32IntAP(I); case PT_IntAPS: return emitFlipUint32IntAPS(I); case PT_Bool: return emitFlipUint32Bool(I); case PT_FixedPoint: return emitFlipUint32FixedPoint(I); case PT_Ptr: return emitFlipUint32Ptr(I); case PT_MemberPtr: return emitFlipUint32MemberPtr(I); case PT_Float: return emitFlipUint32Float(I); } llvm_unreachable("invalid enum value"); case PT_Sint64: switch (T1) { case PT_Sint8: return emitFlipSint64Sint8(I); case PT_Uint8: return emitFlipSint64Uint8(I); case PT_Sint16: return emitFlipSint64Sint16(I); case PT_Uint16: return emitFlipSint64Uint16(I); case PT_Sint32: return emitFlipSint64Sint32(I); case PT_Uint32: return emitFlipSint64Uint32(I); case PT_Sint64: return emitFlipSint64Sint64(I); case PT_Uint64: return emitFlipSint64Uint64(I); case PT_IntAP: return emitFlipSint64IntAP(I); case PT_IntAPS: return emitFlipSint64IntAPS(I); case PT_Bool: return emitFlipSint64Bool(I); case PT_FixedPoint: return emitFlipSint64FixedPoint(I); case PT_Ptr: return emitFlipSint64Ptr(I); case PT_MemberPtr: return emitFlipSint64MemberPtr(I); case PT_Float: return emitFlipSint64Float(I); } llvm_unreachable("invalid enum value"); case PT_Uint64: switch (T1) { case PT_Sint8: return emitFlipUint64Sint8(I); case PT_Uint8: return emitFlipUint64Uint8(I); case PT_Sint16: return emitFlipUint64Sint16(I); case PT_Uint16: return emitFlipUint64Uint16(I); case PT_Sint32: return emitFlipUint64Sint32(I); case PT_Uint32: return emitFlipUint64Uint32(I); case PT_Sint64: return emitFlipUint64Sint64(I); case PT_Uint64: return emitFlipUint64Uint64(I); case PT_IntAP: return emitFlipUint64IntAP(I); case PT_IntAPS: return emitFlipUint64IntAPS(I); case PT_Bool: return emitFlipUint64Bool(I); case PT_FixedPoint: return emitFlipUint64FixedPoint(I); case PT_Ptr: return emitFlipUint64Ptr(I); case PT_MemberPtr: return emitFlipUint64MemberPtr(I); case PT_Float: return emitFlipUint64Float(I); } llvm_unreachable("invalid enum value"); case PT_IntAP: switch (T1) { case PT_Sint8: return emitFlipIntAPSint8(I); case PT_Uint8: return emitFlipIntAPUint8(I); case PT_Sint16: return emitFlipIntAPSint16(I); case PT_Uint16: return emitFlipIntAPUint16(I); case PT_Sint32: return emitFlipIntAPSint32(I); case PT_Uint32: return emitFlipIntAPUint32(I); case PT_Sint64: return emitFlipIntAPSint64(I); case PT_Uint64: return emitFlipIntAPUint64(I); case PT_IntAP: return emitFlipIntAPIntAP(I); case PT_IntAPS: return emitFlipIntAPIntAPS(I); case PT_Bool: return emitFlipIntAPBool(I); case PT_FixedPoint: return emitFlipIntAPFixedPoint(I); case PT_Ptr: return emitFlipIntAPPtr(I); case PT_MemberPtr: return emitFlipIntAPMemberPtr(I); case PT_Float: return emitFlipIntAPFloat(I); } llvm_unreachable("invalid enum value"); case PT_IntAPS: switch (T1) { case PT_Sint8: return emitFlipIntAPSSint8(I); case PT_Uint8: return emitFlipIntAPSUint8(I); case PT_Sint16: return emitFlipIntAPSSint16(I); case PT_Uint16: return emitFlipIntAPSUint16(I); case PT_Sint32: return emitFlipIntAPSSint32(I); case PT_Uint32: return emitFlipIntAPSUint32(I); case PT_Sint64: return emitFlipIntAPSSint64(I); case PT_Uint64: return emitFlipIntAPSUint64(I); case PT_IntAP: return emitFlipIntAPSIntAP(I); case PT_IntAPS: return emitFlipIntAPSIntAPS(I); case PT_Bool: return emitFlipIntAPSBool(I); case PT_FixedPoint: return emitFlipIntAPSFixedPoint(I); case PT_Ptr: return emitFlipIntAPSPtr(I); case PT_MemberPtr: return emitFlipIntAPSMemberPtr(I); case PT_Float: return emitFlipIntAPSFloat(I); } llvm_unreachable("invalid enum value"); case PT_Bool: switch (T1) { case PT_Sint8: return emitFlipBoolSint8(I); case PT_Uint8: return emitFlipBoolUint8(I); case PT_Sint16: return emitFlipBoolSint16(I); case PT_Uint16: return emitFlipBoolUint16(I); case PT_Sint32: return emitFlipBoolSint32(I); case PT_Uint32: return emitFlipBoolUint32(I); case PT_Sint64: return emitFlipBoolSint64(I); case PT_Uint64: return emitFlipBoolUint64(I); case PT_IntAP: return emitFlipBoolIntAP(I); case PT_IntAPS: return emitFlipBoolIntAPS(I); case PT_Bool: return emitFlipBoolBool(I); case PT_FixedPoint: return emitFlipBoolFixedPoint(I); case PT_Ptr: return emitFlipBoolPtr(I); case PT_MemberPtr: return emitFlipBoolMemberPtr(I); case PT_Float: return emitFlipBoolFloat(I); } llvm_unreachable("invalid enum value"); case PT_FixedPoint: switch (T1) { case PT_Sint8: return emitFlipFixedPointSint8(I); case PT_Uint8: return emitFlipFixedPointUint8(I); case PT_Sint16: return emitFlipFixedPointSint16(I); case PT_Uint16: return emitFlipFixedPointUint16(I); case PT_Sint32: return emitFlipFixedPointSint32(I); case PT_Uint32: return emitFlipFixedPointUint32(I); case PT_Sint64: return emitFlipFixedPointSint64(I); case PT_Uint64: return emitFlipFixedPointUint64(I); case PT_IntAP: return emitFlipFixedPointIntAP(I); case PT_IntAPS: return emitFlipFixedPointIntAPS(I); case PT_Bool: return emitFlipFixedPointBool(I); case PT_FixedPoint: return emitFlipFixedPointFixedPoint(I); case PT_Ptr: return emitFlipFixedPointPtr(I); case PT_MemberPtr: return emitFlipFixedPointMemberPtr(I); case PT_Float: return emitFlipFixedPointFloat(I); } llvm_unreachable("invalid enum value"); case PT_Ptr: switch (T1) { case PT_Sint8: return emitFlipPtrSint8(I); case PT_Uint8: return emitFlipPtrUint8(I); case PT_Sint16: return emitFlipPtrSint16(I); case PT_Uint16: return emitFlipPtrUint16(I); case PT_Sint32: return emitFlipPtrSint32(I); case PT_Uint32: return emitFlipPtrUint32(I); case PT_Sint64: return emitFlipPtrSint64(I); case PT_Uint64: return emitFlipPtrUint64(I); case PT_IntAP: return emitFlipPtrIntAP(I); case PT_IntAPS: return emitFlipPtrIntAPS(I); case PT_Bool: return emitFlipPtrBool(I); case PT_FixedPoint: return emitFlipPtrFixedPoint(I); case PT_Ptr: return emitFlipPtrPtr(I); case PT_MemberPtr: return emitFlipPtrMemberPtr(I); case PT_Float: return emitFlipPtrFloat(I); } llvm_unreachable("invalid enum value"); case PT_MemberPtr: switch (T1) { case PT_Sint8: return emitFlipMemberPtrSint8(I); case PT_Uint8: return emitFlipMemberPtrUint8(I); case PT_Sint16: return emitFlipMemberPtrSint16(I); case PT_Uint16: return emitFlipMemberPtrUint16(I); case PT_Sint32: return emitFlipMemberPtrSint32(I); case PT_Uint32: return emitFlipMemberPtrUint32(I); case PT_Sint64: return emitFlipMemberPtrSint64(I); case PT_Uint64: return emitFlipMemberPtrUint64(I); case PT_IntAP: return emitFlipMemberPtrIntAP(I); case PT_IntAPS: return emitFlipMemberPtrIntAPS(I); case PT_Bool: return emitFlipMemberPtrBool(I); case PT_FixedPoint: return emitFlipMemberPtrFixedPoint(I); case PT_Ptr: return emitFlipMemberPtrPtr(I); case PT_MemberPtr: return emitFlipMemberPtrMemberPtr(I); case PT_Float: return emitFlipMemberPtrFloat(I); } llvm_unreachable("invalid enum value"); case PT_Float: switch (T1) { case PT_Sint8: return emitFlipFloatSint8(I); case PT_Uint8: return emitFlipFloatUint8(I); case PT_Sint16: return emitFlipFloatSint16(I); case PT_Uint16: return emitFlipFloatUint16(I); case PT_Sint32: return emitFlipFloatSint32(I); case PT_Uint32: return emitFlipFloatUint32(I); case PT_Sint64: return emitFlipFloatSint64(I); case PT_Uint64: return emitFlipFloatUint64(I); case PT_IntAP: return emitFlipFloatIntAP(I); case PT_IntAPS: return emitFlipFloatIntAPS(I); case PT_Bool: return emitFlipFloatBool(I); case PT_FixedPoint: return emitFlipFloatFixedPoint(I); case PT_Ptr: return emitFlipFloatPtr(I); case PT_MemberPtr: return emitFlipFloatMemberPtr(I); case PT_Float: return emitFlipFloatFloat(I); } llvm_unreachable("invalid enum value"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitFlipSint8Sint8(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Sint8, L); } bool ByteCodeEmitter::emitFlipSint8Uint8(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Uint8, L); } bool ByteCodeEmitter::emitFlipSint8Sint16(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Sint16, L); } bool ByteCodeEmitter::emitFlipSint8Uint16(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Uint16, L); } bool ByteCodeEmitter::emitFlipSint8Sint32(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Sint32, L); } bool ByteCodeEmitter::emitFlipSint8Uint32(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Uint32, L); } bool ByteCodeEmitter::emitFlipSint8Sint64(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Sint64, L); } bool ByteCodeEmitter::emitFlipSint8Uint64(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Uint64, L); } bool ByteCodeEmitter::emitFlipSint8IntAP(const SourceInfo &L) { return emitOp<>(OP_FlipSint8IntAP, L); } bool ByteCodeEmitter::emitFlipSint8IntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipSint8IntAPS, L); } bool ByteCodeEmitter::emitFlipSint8Bool(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Bool, L); } bool ByteCodeEmitter::emitFlipSint8FixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipSint8FixedPoint, L); } bool ByteCodeEmitter::emitFlipSint8Ptr(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Ptr, L); } bool ByteCodeEmitter::emitFlipSint8MemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipSint8MemberPtr, L); } bool ByteCodeEmitter::emitFlipSint8Float(const SourceInfo &L) { return emitOp<>(OP_FlipSint8Float, L); } bool ByteCodeEmitter::emitFlipUint8Sint8(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Sint8, L); } bool ByteCodeEmitter::emitFlipUint8Uint8(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Uint8, L); } bool ByteCodeEmitter::emitFlipUint8Sint16(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Sint16, L); } bool ByteCodeEmitter::emitFlipUint8Uint16(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Uint16, L); } bool ByteCodeEmitter::emitFlipUint8Sint32(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Sint32, L); } bool ByteCodeEmitter::emitFlipUint8Uint32(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Uint32, L); } bool ByteCodeEmitter::emitFlipUint8Sint64(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Sint64, L); } bool ByteCodeEmitter::emitFlipUint8Uint64(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Uint64, L); } bool ByteCodeEmitter::emitFlipUint8IntAP(const SourceInfo &L) { return emitOp<>(OP_FlipUint8IntAP, L); } bool ByteCodeEmitter::emitFlipUint8IntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipUint8IntAPS, L); } bool ByteCodeEmitter::emitFlipUint8Bool(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Bool, L); } bool ByteCodeEmitter::emitFlipUint8FixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipUint8FixedPoint, L); } bool ByteCodeEmitter::emitFlipUint8Ptr(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Ptr, L); } bool ByteCodeEmitter::emitFlipUint8MemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipUint8MemberPtr, L); } bool ByteCodeEmitter::emitFlipUint8Float(const SourceInfo &L) { return emitOp<>(OP_FlipUint8Float, L); } bool ByteCodeEmitter::emitFlipSint16Sint8(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Sint8, L); } bool ByteCodeEmitter::emitFlipSint16Uint8(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Uint8, L); } bool ByteCodeEmitter::emitFlipSint16Sint16(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Sint16, L); } bool ByteCodeEmitter::emitFlipSint16Uint16(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Uint16, L); } bool ByteCodeEmitter::emitFlipSint16Sint32(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Sint32, L); } bool ByteCodeEmitter::emitFlipSint16Uint32(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Uint32, L); } bool ByteCodeEmitter::emitFlipSint16Sint64(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Sint64, L); } bool ByteCodeEmitter::emitFlipSint16Uint64(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Uint64, L); } bool ByteCodeEmitter::emitFlipSint16IntAP(const SourceInfo &L) { return emitOp<>(OP_FlipSint16IntAP, L); } bool ByteCodeEmitter::emitFlipSint16IntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipSint16IntAPS, L); } bool ByteCodeEmitter::emitFlipSint16Bool(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Bool, L); } bool ByteCodeEmitter::emitFlipSint16FixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipSint16FixedPoint, L); } bool ByteCodeEmitter::emitFlipSint16Ptr(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Ptr, L); } bool ByteCodeEmitter::emitFlipSint16MemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipSint16MemberPtr, L); } bool ByteCodeEmitter::emitFlipSint16Float(const SourceInfo &L) { return emitOp<>(OP_FlipSint16Float, L); } bool ByteCodeEmitter::emitFlipUint16Sint8(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Sint8, L); } bool ByteCodeEmitter::emitFlipUint16Uint8(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Uint8, L); } bool ByteCodeEmitter::emitFlipUint16Sint16(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Sint16, L); } bool ByteCodeEmitter::emitFlipUint16Uint16(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Uint16, L); } bool ByteCodeEmitter::emitFlipUint16Sint32(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Sint32, L); } bool ByteCodeEmitter::emitFlipUint16Uint32(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Uint32, L); } bool ByteCodeEmitter::emitFlipUint16Sint64(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Sint64, L); } bool ByteCodeEmitter::emitFlipUint16Uint64(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Uint64, L); } bool ByteCodeEmitter::emitFlipUint16IntAP(const SourceInfo &L) { return emitOp<>(OP_FlipUint16IntAP, L); } bool ByteCodeEmitter::emitFlipUint16IntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipUint16IntAPS, L); } bool ByteCodeEmitter::emitFlipUint16Bool(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Bool, L); } bool ByteCodeEmitter::emitFlipUint16FixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipUint16FixedPoint, L); } bool ByteCodeEmitter::emitFlipUint16Ptr(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Ptr, L); } bool ByteCodeEmitter::emitFlipUint16MemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipUint16MemberPtr, L); } bool ByteCodeEmitter::emitFlipUint16Float(const SourceInfo &L) { return emitOp<>(OP_FlipUint16Float, L); } bool ByteCodeEmitter::emitFlipSint32Sint8(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Sint8, L); } bool ByteCodeEmitter::emitFlipSint32Uint8(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Uint8, L); } bool ByteCodeEmitter::emitFlipSint32Sint16(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Sint16, L); } bool ByteCodeEmitter::emitFlipSint32Uint16(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Uint16, L); } bool ByteCodeEmitter::emitFlipSint32Sint32(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Sint32, L); } bool ByteCodeEmitter::emitFlipSint32Uint32(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Uint32, L); } bool ByteCodeEmitter::emitFlipSint32Sint64(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Sint64, L); } bool ByteCodeEmitter::emitFlipSint32Uint64(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Uint64, L); } bool ByteCodeEmitter::emitFlipSint32IntAP(const SourceInfo &L) { return emitOp<>(OP_FlipSint32IntAP, L); } bool ByteCodeEmitter::emitFlipSint32IntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipSint32IntAPS, L); } bool ByteCodeEmitter::emitFlipSint32Bool(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Bool, L); } bool ByteCodeEmitter::emitFlipSint32FixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipSint32FixedPoint, L); } bool ByteCodeEmitter::emitFlipSint32Ptr(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Ptr, L); } bool ByteCodeEmitter::emitFlipSint32MemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipSint32MemberPtr, L); } bool ByteCodeEmitter::emitFlipSint32Float(const SourceInfo &L) { return emitOp<>(OP_FlipSint32Float, L); } bool ByteCodeEmitter::emitFlipUint32Sint8(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Sint8, L); } bool ByteCodeEmitter::emitFlipUint32Uint8(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Uint8, L); } bool ByteCodeEmitter::emitFlipUint32Sint16(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Sint16, L); } bool ByteCodeEmitter::emitFlipUint32Uint16(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Uint16, L); } bool ByteCodeEmitter::emitFlipUint32Sint32(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Sint32, L); } bool ByteCodeEmitter::emitFlipUint32Uint32(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Uint32, L); } bool ByteCodeEmitter::emitFlipUint32Sint64(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Sint64, L); } bool ByteCodeEmitter::emitFlipUint32Uint64(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Uint64, L); } bool ByteCodeEmitter::emitFlipUint32IntAP(const SourceInfo &L) { return emitOp<>(OP_FlipUint32IntAP, L); } bool ByteCodeEmitter::emitFlipUint32IntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipUint32IntAPS, L); } bool ByteCodeEmitter::emitFlipUint32Bool(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Bool, L); } bool ByteCodeEmitter::emitFlipUint32FixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipUint32FixedPoint, L); } bool ByteCodeEmitter::emitFlipUint32Ptr(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Ptr, L); } bool ByteCodeEmitter::emitFlipUint32MemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipUint32MemberPtr, L); } bool ByteCodeEmitter::emitFlipUint32Float(const SourceInfo &L) { return emitOp<>(OP_FlipUint32Float, L); } bool ByteCodeEmitter::emitFlipSint64Sint8(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Sint8, L); } bool ByteCodeEmitter::emitFlipSint64Uint8(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Uint8, L); } bool ByteCodeEmitter::emitFlipSint64Sint16(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Sint16, L); } bool ByteCodeEmitter::emitFlipSint64Uint16(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Uint16, L); } bool ByteCodeEmitter::emitFlipSint64Sint32(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Sint32, L); } bool ByteCodeEmitter::emitFlipSint64Uint32(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Uint32, L); } bool ByteCodeEmitter::emitFlipSint64Sint64(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Sint64, L); } bool ByteCodeEmitter::emitFlipSint64Uint64(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Uint64, L); } bool ByteCodeEmitter::emitFlipSint64IntAP(const SourceInfo &L) { return emitOp<>(OP_FlipSint64IntAP, L); } bool ByteCodeEmitter::emitFlipSint64IntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipSint64IntAPS, L); } bool ByteCodeEmitter::emitFlipSint64Bool(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Bool, L); } bool ByteCodeEmitter::emitFlipSint64FixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipSint64FixedPoint, L); } bool ByteCodeEmitter::emitFlipSint64Ptr(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Ptr, L); } bool ByteCodeEmitter::emitFlipSint64MemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipSint64MemberPtr, L); } bool ByteCodeEmitter::emitFlipSint64Float(const SourceInfo &L) { return emitOp<>(OP_FlipSint64Float, L); } bool ByteCodeEmitter::emitFlipUint64Sint8(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Sint8, L); } bool ByteCodeEmitter::emitFlipUint64Uint8(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Uint8, L); } bool ByteCodeEmitter::emitFlipUint64Sint16(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Sint16, L); } bool ByteCodeEmitter::emitFlipUint64Uint16(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Uint16, L); } bool ByteCodeEmitter::emitFlipUint64Sint32(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Sint32, L); } bool ByteCodeEmitter::emitFlipUint64Uint32(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Uint32, L); } bool ByteCodeEmitter::emitFlipUint64Sint64(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Sint64, L); } bool ByteCodeEmitter::emitFlipUint64Uint64(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Uint64, L); } bool ByteCodeEmitter::emitFlipUint64IntAP(const SourceInfo &L) { return emitOp<>(OP_FlipUint64IntAP, L); } bool ByteCodeEmitter::emitFlipUint64IntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipUint64IntAPS, L); } bool ByteCodeEmitter::emitFlipUint64Bool(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Bool, L); } bool ByteCodeEmitter::emitFlipUint64FixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipUint64FixedPoint, L); } bool ByteCodeEmitter::emitFlipUint64Ptr(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Ptr, L); } bool ByteCodeEmitter::emitFlipUint64MemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipUint64MemberPtr, L); } bool ByteCodeEmitter::emitFlipUint64Float(const SourceInfo &L) { return emitOp<>(OP_FlipUint64Float, L); } bool ByteCodeEmitter::emitFlipIntAPSint8(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSint8, L); } bool ByteCodeEmitter::emitFlipIntAPUint8(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPUint8, L); } bool ByteCodeEmitter::emitFlipIntAPSint16(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSint16, L); } bool ByteCodeEmitter::emitFlipIntAPUint16(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPUint16, L); } bool ByteCodeEmitter::emitFlipIntAPSint32(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSint32, L); } bool ByteCodeEmitter::emitFlipIntAPUint32(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPUint32, L); } bool ByteCodeEmitter::emitFlipIntAPSint64(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSint64, L); } bool ByteCodeEmitter::emitFlipIntAPUint64(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPUint64, L); } bool ByteCodeEmitter::emitFlipIntAPIntAP(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPIntAP, L); } bool ByteCodeEmitter::emitFlipIntAPIntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPIntAPS, L); } bool ByteCodeEmitter::emitFlipIntAPBool(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPBool, L); } bool ByteCodeEmitter::emitFlipIntAPFixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPFixedPoint, L); } bool ByteCodeEmitter::emitFlipIntAPPtr(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPPtr, L); } bool ByteCodeEmitter::emitFlipIntAPMemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPMemberPtr, L); } bool ByteCodeEmitter::emitFlipIntAPFloat(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPFloat, L); } bool ByteCodeEmitter::emitFlipIntAPSSint8(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSSint8, L); } bool ByteCodeEmitter::emitFlipIntAPSUint8(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSUint8, L); } bool ByteCodeEmitter::emitFlipIntAPSSint16(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSSint16, L); } bool ByteCodeEmitter::emitFlipIntAPSUint16(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSUint16, L); } bool ByteCodeEmitter::emitFlipIntAPSSint32(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSSint32, L); } bool ByteCodeEmitter::emitFlipIntAPSUint32(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSUint32, L); } bool ByteCodeEmitter::emitFlipIntAPSSint64(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSSint64, L); } bool ByteCodeEmitter::emitFlipIntAPSUint64(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSUint64, L); } bool ByteCodeEmitter::emitFlipIntAPSIntAP(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSIntAP, L); } bool ByteCodeEmitter::emitFlipIntAPSIntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSIntAPS, L); } bool ByteCodeEmitter::emitFlipIntAPSBool(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSBool, L); } bool ByteCodeEmitter::emitFlipIntAPSFixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSFixedPoint, L); } bool ByteCodeEmitter::emitFlipIntAPSPtr(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSPtr, L); } bool ByteCodeEmitter::emitFlipIntAPSMemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSMemberPtr, L); } bool ByteCodeEmitter::emitFlipIntAPSFloat(const SourceInfo &L) { return emitOp<>(OP_FlipIntAPSFloat, L); } bool ByteCodeEmitter::emitFlipBoolSint8(const SourceInfo &L) { return emitOp<>(OP_FlipBoolSint8, L); } bool ByteCodeEmitter::emitFlipBoolUint8(const SourceInfo &L) { return emitOp<>(OP_FlipBoolUint8, L); } bool ByteCodeEmitter::emitFlipBoolSint16(const SourceInfo &L) { return emitOp<>(OP_FlipBoolSint16, L); } bool ByteCodeEmitter::emitFlipBoolUint16(const SourceInfo &L) { return emitOp<>(OP_FlipBoolUint16, L); } bool ByteCodeEmitter::emitFlipBoolSint32(const SourceInfo &L) { return emitOp<>(OP_FlipBoolSint32, L); } bool ByteCodeEmitter::emitFlipBoolUint32(const SourceInfo &L) { return emitOp<>(OP_FlipBoolUint32, L); } bool ByteCodeEmitter::emitFlipBoolSint64(const SourceInfo &L) { return emitOp<>(OP_FlipBoolSint64, L); } bool ByteCodeEmitter::emitFlipBoolUint64(const SourceInfo &L) { return emitOp<>(OP_FlipBoolUint64, L); } bool ByteCodeEmitter::emitFlipBoolIntAP(const SourceInfo &L) { return emitOp<>(OP_FlipBoolIntAP, L); } bool ByteCodeEmitter::emitFlipBoolIntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipBoolIntAPS, L); } bool ByteCodeEmitter::emitFlipBoolBool(const SourceInfo &L) { return emitOp<>(OP_FlipBoolBool, L); } bool ByteCodeEmitter::emitFlipBoolFixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipBoolFixedPoint, L); } bool ByteCodeEmitter::emitFlipBoolPtr(const SourceInfo &L) { return emitOp<>(OP_FlipBoolPtr, L); } bool ByteCodeEmitter::emitFlipBoolMemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipBoolMemberPtr, L); } bool ByteCodeEmitter::emitFlipBoolFloat(const SourceInfo &L) { return emitOp<>(OP_FlipBoolFloat, L); } bool ByteCodeEmitter::emitFlipFixedPointSint8(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointSint8, L); } bool ByteCodeEmitter::emitFlipFixedPointUint8(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointUint8, L); } bool ByteCodeEmitter::emitFlipFixedPointSint16(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointSint16, L); } bool ByteCodeEmitter::emitFlipFixedPointUint16(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointUint16, L); } bool ByteCodeEmitter::emitFlipFixedPointSint32(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointSint32, L); } bool ByteCodeEmitter::emitFlipFixedPointUint32(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointUint32, L); } bool ByteCodeEmitter::emitFlipFixedPointSint64(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointSint64, L); } bool ByteCodeEmitter::emitFlipFixedPointUint64(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointUint64, L); } bool ByteCodeEmitter::emitFlipFixedPointIntAP(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointIntAP, L); } bool ByteCodeEmitter::emitFlipFixedPointIntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointIntAPS, L); } bool ByteCodeEmitter::emitFlipFixedPointBool(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointBool, L); } bool ByteCodeEmitter::emitFlipFixedPointFixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointFixedPoint, L); } bool ByteCodeEmitter::emitFlipFixedPointPtr(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointPtr, L); } bool ByteCodeEmitter::emitFlipFixedPointMemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointMemberPtr, L); } bool ByteCodeEmitter::emitFlipFixedPointFloat(const SourceInfo &L) { return emitOp<>(OP_FlipFixedPointFloat, L); } bool ByteCodeEmitter::emitFlipPtrSint8(const SourceInfo &L) { return emitOp<>(OP_FlipPtrSint8, L); } bool ByteCodeEmitter::emitFlipPtrUint8(const SourceInfo &L) { return emitOp<>(OP_FlipPtrUint8, L); } bool ByteCodeEmitter::emitFlipPtrSint16(const SourceInfo &L) { return emitOp<>(OP_FlipPtrSint16, L); } bool ByteCodeEmitter::emitFlipPtrUint16(const SourceInfo &L) { return emitOp<>(OP_FlipPtrUint16, L); } bool ByteCodeEmitter::emitFlipPtrSint32(const SourceInfo &L) { return emitOp<>(OP_FlipPtrSint32, L); } bool ByteCodeEmitter::emitFlipPtrUint32(const SourceInfo &L) { return emitOp<>(OP_FlipPtrUint32, L); } bool ByteCodeEmitter::emitFlipPtrSint64(const SourceInfo &L) { return emitOp<>(OP_FlipPtrSint64, L); } bool ByteCodeEmitter::emitFlipPtrUint64(const SourceInfo &L) { return emitOp<>(OP_FlipPtrUint64, L); } bool ByteCodeEmitter::emitFlipPtrIntAP(const SourceInfo &L) { return emitOp<>(OP_FlipPtrIntAP, L); } bool ByteCodeEmitter::emitFlipPtrIntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipPtrIntAPS, L); } bool ByteCodeEmitter::emitFlipPtrBool(const SourceInfo &L) { return emitOp<>(OP_FlipPtrBool, L); } bool ByteCodeEmitter::emitFlipPtrFixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipPtrFixedPoint, L); } bool ByteCodeEmitter::emitFlipPtrPtr(const SourceInfo &L) { return emitOp<>(OP_FlipPtrPtr, L); } bool ByteCodeEmitter::emitFlipPtrMemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipPtrMemberPtr, L); } bool ByteCodeEmitter::emitFlipPtrFloat(const SourceInfo &L) { return emitOp<>(OP_FlipPtrFloat, L); } bool ByteCodeEmitter::emitFlipMemberPtrSint8(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrSint8, L); } bool ByteCodeEmitter::emitFlipMemberPtrUint8(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrUint8, L); } bool ByteCodeEmitter::emitFlipMemberPtrSint16(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrSint16, L); } bool ByteCodeEmitter::emitFlipMemberPtrUint16(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrUint16, L); } bool ByteCodeEmitter::emitFlipMemberPtrSint32(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrSint32, L); } bool ByteCodeEmitter::emitFlipMemberPtrUint32(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrUint32, L); } bool ByteCodeEmitter::emitFlipMemberPtrSint64(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrSint64, L); } bool ByteCodeEmitter::emitFlipMemberPtrUint64(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrUint64, L); } bool ByteCodeEmitter::emitFlipMemberPtrIntAP(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrIntAP, L); } bool ByteCodeEmitter::emitFlipMemberPtrIntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrIntAPS, L); } bool ByteCodeEmitter::emitFlipMemberPtrBool(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrBool, L); } bool ByteCodeEmitter::emitFlipMemberPtrFixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrFixedPoint, L); } bool ByteCodeEmitter::emitFlipMemberPtrPtr(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrPtr, L); } bool ByteCodeEmitter::emitFlipMemberPtrMemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrMemberPtr, L); } bool ByteCodeEmitter::emitFlipMemberPtrFloat(const SourceInfo &L) { return emitOp<>(OP_FlipMemberPtrFloat, L); } bool ByteCodeEmitter::emitFlipFloatSint8(const SourceInfo &L) { return emitOp<>(OP_FlipFloatSint8, L); } bool ByteCodeEmitter::emitFlipFloatUint8(const SourceInfo &L) { return emitOp<>(OP_FlipFloatUint8, L); } bool ByteCodeEmitter::emitFlipFloatSint16(const SourceInfo &L) { return emitOp<>(OP_FlipFloatSint16, L); } bool ByteCodeEmitter::emitFlipFloatUint16(const SourceInfo &L) { return emitOp<>(OP_FlipFloatUint16, L); } bool ByteCodeEmitter::emitFlipFloatSint32(const SourceInfo &L) { return emitOp<>(OP_FlipFloatSint32, L); } bool ByteCodeEmitter::emitFlipFloatUint32(const SourceInfo &L) { return emitOp<>(OP_FlipFloatUint32, L); } bool ByteCodeEmitter::emitFlipFloatSint64(const SourceInfo &L) { return emitOp<>(OP_FlipFloatSint64, L); } bool ByteCodeEmitter::emitFlipFloatUint64(const SourceInfo &L) { return emitOp<>(OP_FlipFloatUint64, L); } bool ByteCodeEmitter::emitFlipFloatIntAP(const SourceInfo &L) { return emitOp<>(OP_FlipFloatIntAP, L); } bool ByteCodeEmitter::emitFlipFloatIntAPS(const SourceInfo &L) { return emitOp<>(OP_FlipFloatIntAPS, L); } bool ByteCodeEmitter::emitFlipFloatBool(const SourceInfo &L) { return emitOp<>(OP_FlipFloatBool, L); } bool ByteCodeEmitter::emitFlipFloatFixedPoint(const SourceInfo &L) { return emitOp<>(OP_FlipFloatFixedPoint, L); } bool ByteCodeEmitter::emitFlipFloatPtr(const SourceInfo &L) { return emitOp<>(OP_FlipFloatPtr, L); } bool ByteCodeEmitter::emitFlipFloatMemberPtr(const SourceInfo &L) { return emitOp<>(OP_FlipFloatMemberPtr, L); } bool ByteCodeEmitter::emitFlipFloatFloat(const SourceInfo &L) { return emitOp<>(OP_FlipFloatFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitFlipSint8Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8FixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Ptr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8MemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint8Float(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8FixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Ptr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8MemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint8Float(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16FixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Ptr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16MemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint16Float(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16FixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Ptr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16MemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint16Float(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32FixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Ptr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32MemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint32Float(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32FixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Ptr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32MemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint32Float(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64FixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Ptr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64MemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipSint64Float(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Bool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64FixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Ptr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64MemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipUint64Float(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipIntAPSFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipBoolFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFixedPointFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipPtrFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipMemberPtrFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } bool EvalEmitter::emitFlipFloatFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Flip(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Free, #endif #ifdef GET_INTERP case OP_Free: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!Free(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_Free: Text.Op = PrintName("Free"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitFree( bool , bool , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitFree( bool A0, bool A1, const SourceInfo &L) { return emitOp(OP_Free, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitFree( bool A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Free(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_GESint8, OP_GEUint8, OP_GESint16, OP_GEUint16, OP_GESint32, OP_GEUint32, OP_GESint64, OP_GEUint64, OP_GEIntAP, OP_GEIntAPS, OP_GEBool, OP_GEFixedPoint, OP_GEPtr, OP_GEFloat, #endif #ifdef GET_INTERP case OP_GESint8: { if (!GE(S, OpPC)) return false; continue; } case OP_GEUint8: { if (!GE(S, OpPC)) return false; continue; } case OP_GESint16: { if (!GE(S, OpPC)) return false; continue; } case OP_GEUint16: { if (!GE(S, OpPC)) return false; continue; } case OP_GESint32: { if (!GE(S, OpPC)) return false; continue; } case OP_GEUint32: { if (!GE(S, OpPC)) return false; continue; } case OP_GESint64: { if (!GE(S, OpPC)) return false; continue; } case OP_GEUint64: { if (!GE(S, OpPC)) return false; continue; } case OP_GEIntAP: { if (!GE(S, OpPC)) return false; continue; } case OP_GEIntAPS: { if (!GE(S, OpPC)) return false; continue; } case OP_GEBool: { if (!GE(S, OpPC)) return false; continue; } case OP_GEFixedPoint: { if (!GE(S, OpPC)) return false; continue; } case OP_GEPtr: { if (!GE(S, OpPC)) return false; continue; } case OP_GEFloat: { if (!GE(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_GESint8: Text.Op = PrintName("GESint8"); break; case OP_GEUint8: Text.Op = PrintName("GEUint8"); break; case OP_GESint16: Text.Op = PrintName("GESint16"); break; case OP_GEUint16: Text.Op = PrintName("GEUint16"); break; case OP_GESint32: Text.Op = PrintName("GESint32"); break; case OP_GEUint32: Text.Op = PrintName("GEUint32"); break; case OP_GESint64: Text.Op = PrintName("GESint64"); break; case OP_GEUint64: Text.Op = PrintName("GEUint64"); break; case OP_GEIntAP: Text.Op = PrintName("GEIntAP"); break; case OP_GEIntAPS: Text.Op = PrintName("GEIntAPS"); break; case OP_GEBool: Text.Op = PrintName("GEBool"); break; case OP_GEFixedPoint: Text.Op = PrintName("GEFixedPoint"); break; case OP_GEPtr: Text.Op = PrintName("GEPtr"); break; case OP_GEFloat: Text.Op = PrintName("GEFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGESint8(const SourceInfo &); bool emitGEUint8(const SourceInfo &); bool emitGESint16(const SourceInfo &); bool emitGEUint16(const SourceInfo &); bool emitGESint32(const SourceInfo &); bool emitGEUint32(const SourceInfo &); bool emitGESint64(const SourceInfo &); bool emitGEUint64(const SourceInfo &); bool emitGEIntAP(const SourceInfo &); bool emitGEIntAPS(const SourceInfo &); bool emitGEBool(const SourceInfo &); bool emitGEFixedPoint(const SourceInfo &); bool emitGEPtr(const SourceInfo &); bool emitGEFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGE(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGE(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitGESint8(I); case PT_Uint8: return emitGEUint8(I); case PT_Sint16: return emitGESint16(I); case PT_Uint16: return emitGEUint16(I); case PT_Sint32: return emitGESint32(I); case PT_Uint32: return emitGEUint32(I); case PT_Sint64: return emitGESint64(I); case PT_Uint64: return emitGEUint64(I); case PT_IntAP: return emitGEIntAP(I); case PT_IntAPS: return emitGEIntAPS(I); case PT_Bool: return emitGEBool(I); case PT_FixedPoint: return emitGEFixedPoint(I); case PT_Ptr: return emitGEPtr(I); case PT_Float: return emitGEFloat(I); default: llvm_unreachable("invalid type: emitGE"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGESint8(const SourceInfo &L) { return emitOp<>(OP_GESint8, L); } bool ByteCodeEmitter::emitGEUint8(const SourceInfo &L) { return emitOp<>(OP_GEUint8, L); } bool ByteCodeEmitter::emitGESint16(const SourceInfo &L) { return emitOp<>(OP_GESint16, L); } bool ByteCodeEmitter::emitGEUint16(const SourceInfo &L) { return emitOp<>(OP_GEUint16, L); } bool ByteCodeEmitter::emitGESint32(const SourceInfo &L) { return emitOp<>(OP_GESint32, L); } bool ByteCodeEmitter::emitGEUint32(const SourceInfo &L) { return emitOp<>(OP_GEUint32, L); } bool ByteCodeEmitter::emitGESint64(const SourceInfo &L) { return emitOp<>(OP_GESint64, L); } bool ByteCodeEmitter::emitGEUint64(const SourceInfo &L) { return emitOp<>(OP_GEUint64, L); } bool ByteCodeEmitter::emitGEIntAP(const SourceInfo &L) { return emitOp<>(OP_GEIntAP, L); } bool ByteCodeEmitter::emitGEIntAPS(const SourceInfo &L) { return emitOp<>(OP_GEIntAPS, L); } bool ByteCodeEmitter::emitGEBool(const SourceInfo &L) { return emitOp<>(OP_GEBool, L); } bool ByteCodeEmitter::emitGEFixedPoint(const SourceInfo &L) { return emitOp<>(OP_GEFixedPoint, L); } bool ByteCodeEmitter::emitGEPtr(const SourceInfo &L) { return emitOp<>(OP_GEPtr, L); } bool ByteCodeEmitter::emitGEFloat(const SourceInfo &L) { return emitOp<>(OP_GEFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGESint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGESint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGESint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGESint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } bool EvalEmitter::emitGEFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GE(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_GTSint8, OP_GTUint8, OP_GTSint16, OP_GTUint16, OP_GTSint32, OP_GTUint32, OP_GTSint64, OP_GTUint64, OP_GTIntAP, OP_GTIntAPS, OP_GTBool, OP_GTFixedPoint, OP_GTPtr, OP_GTFloat, #endif #ifdef GET_INTERP case OP_GTSint8: { if (!GT(S, OpPC)) return false; continue; } case OP_GTUint8: { if (!GT(S, OpPC)) return false; continue; } case OP_GTSint16: { if (!GT(S, OpPC)) return false; continue; } case OP_GTUint16: { if (!GT(S, OpPC)) return false; continue; } case OP_GTSint32: { if (!GT(S, OpPC)) return false; continue; } case OP_GTUint32: { if (!GT(S, OpPC)) return false; continue; } case OP_GTSint64: { if (!GT(S, OpPC)) return false; continue; } case OP_GTUint64: { if (!GT(S, OpPC)) return false; continue; } case OP_GTIntAP: { if (!GT(S, OpPC)) return false; continue; } case OP_GTIntAPS: { if (!GT(S, OpPC)) return false; continue; } case OP_GTBool: { if (!GT(S, OpPC)) return false; continue; } case OP_GTFixedPoint: { if (!GT(S, OpPC)) return false; continue; } case OP_GTPtr: { if (!GT(S, OpPC)) return false; continue; } case OP_GTFloat: { if (!GT(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_GTSint8: Text.Op = PrintName("GTSint8"); break; case OP_GTUint8: Text.Op = PrintName("GTUint8"); break; case OP_GTSint16: Text.Op = PrintName("GTSint16"); break; case OP_GTUint16: Text.Op = PrintName("GTUint16"); break; case OP_GTSint32: Text.Op = PrintName("GTSint32"); break; case OP_GTUint32: Text.Op = PrintName("GTUint32"); break; case OP_GTSint64: Text.Op = PrintName("GTSint64"); break; case OP_GTUint64: Text.Op = PrintName("GTUint64"); break; case OP_GTIntAP: Text.Op = PrintName("GTIntAP"); break; case OP_GTIntAPS: Text.Op = PrintName("GTIntAPS"); break; case OP_GTBool: Text.Op = PrintName("GTBool"); break; case OP_GTFixedPoint: Text.Op = PrintName("GTFixedPoint"); break; case OP_GTPtr: Text.Op = PrintName("GTPtr"); break; case OP_GTFloat: Text.Op = PrintName("GTFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGTSint8(const SourceInfo &); bool emitGTUint8(const SourceInfo &); bool emitGTSint16(const SourceInfo &); bool emitGTUint16(const SourceInfo &); bool emitGTSint32(const SourceInfo &); bool emitGTUint32(const SourceInfo &); bool emitGTSint64(const SourceInfo &); bool emitGTUint64(const SourceInfo &); bool emitGTIntAP(const SourceInfo &); bool emitGTIntAPS(const SourceInfo &); bool emitGTBool(const SourceInfo &); bool emitGTFixedPoint(const SourceInfo &); bool emitGTPtr(const SourceInfo &); bool emitGTFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGT(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGT(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitGTSint8(I); case PT_Uint8: return emitGTUint8(I); case PT_Sint16: return emitGTSint16(I); case PT_Uint16: return emitGTUint16(I); case PT_Sint32: return emitGTSint32(I); case PT_Uint32: return emitGTUint32(I); case PT_Sint64: return emitGTSint64(I); case PT_Uint64: return emitGTUint64(I); case PT_IntAP: return emitGTIntAP(I); case PT_IntAPS: return emitGTIntAPS(I); case PT_Bool: return emitGTBool(I); case PT_FixedPoint: return emitGTFixedPoint(I); case PT_Ptr: return emitGTPtr(I); case PT_Float: return emitGTFloat(I); default: llvm_unreachable("invalid type: emitGT"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGTSint8(const SourceInfo &L) { return emitOp<>(OP_GTSint8, L); } bool ByteCodeEmitter::emitGTUint8(const SourceInfo &L) { return emitOp<>(OP_GTUint8, L); } bool ByteCodeEmitter::emitGTSint16(const SourceInfo &L) { return emitOp<>(OP_GTSint16, L); } bool ByteCodeEmitter::emitGTUint16(const SourceInfo &L) { return emitOp<>(OP_GTUint16, L); } bool ByteCodeEmitter::emitGTSint32(const SourceInfo &L) { return emitOp<>(OP_GTSint32, L); } bool ByteCodeEmitter::emitGTUint32(const SourceInfo &L) { return emitOp<>(OP_GTUint32, L); } bool ByteCodeEmitter::emitGTSint64(const SourceInfo &L) { return emitOp<>(OP_GTSint64, L); } bool ByteCodeEmitter::emitGTUint64(const SourceInfo &L) { return emitOp<>(OP_GTUint64, L); } bool ByteCodeEmitter::emitGTIntAP(const SourceInfo &L) { return emitOp<>(OP_GTIntAP, L); } bool ByteCodeEmitter::emitGTIntAPS(const SourceInfo &L) { return emitOp<>(OP_GTIntAPS, L); } bool ByteCodeEmitter::emitGTBool(const SourceInfo &L) { return emitOp<>(OP_GTBool, L); } bool ByteCodeEmitter::emitGTFixedPoint(const SourceInfo &L) { return emitOp<>(OP_GTFixedPoint, L); } bool ByteCodeEmitter::emitGTPtr(const SourceInfo &L) { return emitOp<>(OP_GTPtr, L); } bool ByteCodeEmitter::emitGTFloat(const SourceInfo &L) { return emitOp<>(OP_GTFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGTSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } bool EvalEmitter::emitGTFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GT(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_GetFieldSint8, OP_GetFieldUint8, OP_GetFieldSint16, OP_GetFieldUint16, OP_GetFieldSint32, OP_GetFieldUint32, OP_GetFieldSint64, OP_GetFieldUint64, OP_GetFieldIntAP, OP_GetFieldIntAPS, OP_GetFieldBool, OP_GetFieldFixedPoint, OP_GetFieldPtr, OP_GetFieldMemberPtr, OP_GetFieldFloat, #endif #ifdef GET_INTERP case OP_GetFieldSint8: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldUint8: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldSint16: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldUint16: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldSint32: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldUint32: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldSint64: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldUint64: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldIntAP: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldIntAPS: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldBool: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldFixedPoint: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldPtr: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldMemberPtr: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } case OP_GetFieldFloat: { const auto V0 = ReadArg(S, PC); if (!GetField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetFieldSint8: Text.Op = PrintName("GetFieldSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldUint8: Text.Op = PrintName("GetFieldUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldSint16: Text.Op = PrintName("GetFieldSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldUint16: Text.Op = PrintName("GetFieldUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldSint32: Text.Op = PrintName("GetFieldSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldUint32: Text.Op = PrintName("GetFieldUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldSint64: Text.Op = PrintName("GetFieldSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldUint64: Text.Op = PrintName("GetFieldUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldIntAP: Text.Op = PrintName("GetFieldIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldIntAPS: Text.Op = PrintName("GetFieldIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldBool: Text.Op = PrintName("GetFieldBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldFixedPoint: Text.Op = PrintName("GetFieldFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPtr: Text.Op = PrintName("GetFieldPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldMemberPtr: Text.Op = PrintName("GetFieldMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldFloat: Text.Op = PrintName("GetFieldFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetFieldSint8( uint32_t , const SourceInfo &); bool emitGetFieldUint8( uint32_t , const SourceInfo &); bool emitGetFieldSint16( uint32_t , const SourceInfo &); bool emitGetFieldUint16( uint32_t , const SourceInfo &); bool emitGetFieldSint32( uint32_t , const SourceInfo &); bool emitGetFieldUint32( uint32_t , const SourceInfo &); bool emitGetFieldSint64( uint32_t , const SourceInfo &); bool emitGetFieldUint64( uint32_t , const SourceInfo &); bool emitGetFieldIntAP( uint32_t , const SourceInfo &); bool emitGetFieldIntAPS( uint32_t , const SourceInfo &); bool emitGetFieldBool( uint32_t , const SourceInfo &); bool emitGetFieldFixedPoint( uint32_t , const SourceInfo &); bool emitGetFieldPtr( uint32_t , const SourceInfo &); bool emitGetFieldMemberPtr( uint32_t , const SourceInfo &); bool emitGetFieldFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGetField(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGetField(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitGetFieldSint8(A0, I); case PT_Uint8: return emitGetFieldUint8(A0, I); case PT_Sint16: return emitGetFieldSint16(A0, I); case PT_Uint16: return emitGetFieldUint16(A0, I); case PT_Sint32: return emitGetFieldSint32(A0, I); case PT_Uint32: return emitGetFieldUint32(A0, I); case PT_Sint64: return emitGetFieldSint64(A0, I); case PT_Uint64: return emitGetFieldUint64(A0, I); case PT_IntAP: return emitGetFieldIntAP(A0, I); case PT_IntAPS: return emitGetFieldIntAPS(A0, I); case PT_Bool: return emitGetFieldBool(A0, I); case PT_FixedPoint: return emitGetFieldFixedPoint(A0, I); case PT_Ptr: return emitGetFieldPtr(A0, I); case PT_MemberPtr: return emitGetFieldMemberPtr(A0, I); case PT_Float: return emitGetFieldFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetFieldSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldSint8, A0, L); } bool ByteCodeEmitter::emitGetFieldUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldUint8, A0, L); } bool ByteCodeEmitter::emitGetFieldSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldSint16, A0, L); } bool ByteCodeEmitter::emitGetFieldUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldUint16, A0, L); } bool ByteCodeEmitter::emitGetFieldSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldSint32, A0, L); } bool ByteCodeEmitter::emitGetFieldUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldUint32, A0, L); } bool ByteCodeEmitter::emitGetFieldSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldSint64, A0, L); } bool ByteCodeEmitter::emitGetFieldUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldUint64, A0, L); } bool ByteCodeEmitter::emitGetFieldIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldIntAP, A0, L); } bool ByteCodeEmitter::emitGetFieldIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldIntAPS, A0, L); } bool ByteCodeEmitter::emitGetFieldBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldBool, A0, L); } bool ByteCodeEmitter::emitGetFieldFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldFixedPoint, A0, L); } bool ByteCodeEmitter::emitGetFieldPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPtr, A0, L); } bool ByteCodeEmitter::emitGetFieldMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldMemberPtr, A0, L); } bool ByteCodeEmitter::emitGetFieldFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetFieldSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } bool EvalEmitter::emitGetFieldFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetFieldPopSint8, OP_GetFieldPopUint8, OP_GetFieldPopSint16, OP_GetFieldPopUint16, OP_GetFieldPopSint32, OP_GetFieldPopUint32, OP_GetFieldPopSint64, OP_GetFieldPopUint64, OP_GetFieldPopIntAP, OP_GetFieldPopIntAPS, OP_GetFieldPopBool, OP_GetFieldPopFixedPoint, OP_GetFieldPopPtr, OP_GetFieldPopMemberPtr, OP_GetFieldPopFloat, #endif #ifdef GET_INTERP case OP_GetFieldPopSint8: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopUint8: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopSint16: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopUint16: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopSint32: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopUint32: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopSint64: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopUint64: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopIntAP: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopIntAPS: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopBool: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopFixedPoint: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopPtr: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopMemberPtr: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } case OP_GetFieldPopFloat: { const auto V0 = ReadArg(S, PC); if (!GetFieldPop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetFieldPopSint8: Text.Op = PrintName("GetFieldPopSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopUint8: Text.Op = PrintName("GetFieldPopUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopSint16: Text.Op = PrintName("GetFieldPopSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopUint16: Text.Op = PrintName("GetFieldPopUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopSint32: Text.Op = PrintName("GetFieldPopSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopUint32: Text.Op = PrintName("GetFieldPopUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopSint64: Text.Op = PrintName("GetFieldPopSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopUint64: Text.Op = PrintName("GetFieldPopUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopIntAP: Text.Op = PrintName("GetFieldPopIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopIntAPS: Text.Op = PrintName("GetFieldPopIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopBool: Text.Op = PrintName("GetFieldPopBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopFixedPoint: Text.Op = PrintName("GetFieldPopFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopPtr: Text.Op = PrintName("GetFieldPopPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopMemberPtr: Text.Op = PrintName("GetFieldPopMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetFieldPopFloat: Text.Op = PrintName("GetFieldPopFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetFieldPopSint8( uint32_t , const SourceInfo &); bool emitGetFieldPopUint8( uint32_t , const SourceInfo &); bool emitGetFieldPopSint16( uint32_t , const SourceInfo &); bool emitGetFieldPopUint16( uint32_t , const SourceInfo &); bool emitGetFieldPopSint32( uint32_t , const SourceInfo &); bool emitGetFieldPopUint32( uint32_t , const SourceInfo &); bool emitGetFieldPopSint64( uint32_t , const SourceInfo &); bool emitGetFieldPopUint64( uint32_t , const SourceInfo &); bool emitGetFieldPopIntAP( uint32_t , const SourceInfo &); bool emitGetFieldPopIntAPS( uint32_t , const SourceInfo &); bool emitGetFieldPopBool( uint32_t , const SourceInfo &); bool emitGetFieldPopFixedPoint( uint32_t , const SourceInfo &); bool emitGetFieldPopPtr( uint32_t , const SourceInfo &); bool emitGetFieldPopMemberPtr( uint32_t , const SourceInfo &); bool emitGetFieldPopFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGetFieldPop(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGetFieldPop(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitGetFieldPopSint8(A0, I); case PT_Uint8: return emitGetFieldPopUint8(A0, I); case PT_Sint16: return emitGetFieldPopSint16(A0, I); case PT_Uint16: return emitGetFieldPopUint16(A0, I); case PT_Sint32: return emitGetFieldPopSint32(A0, I); case PT_Uint32: return emitGetFieldPopUint32(A0, I); case PT_Sint64: return emitGetFieldPopSint64(A0, I); case PT_Uint64: return emitGetFieldPopUint64(A0, I); case PT_IntAP: return emitGetFieldPopIntAP(A0, I); case PT_IntAPS: return emitGetFieldPopIntAPS(A0, I); case PT_Bool: return emitGetFieldPopBool(A0, I); case PT_FixedPoint: return emitGetFieldPopFixedPoint(A0, I); case PT_Ptr: return emitGetFieldPopPtr(A0, I); case PT_MemberPtr: return emitGetFieldPopMemberPtr(A0, I); case PT_Float: return emitGetFieldPopFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetFieldPopSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopSint8, A0, L); } bool ByteCodeEmitter::emitGetFieldPopUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopUint8, A0, L); } bool ByteCodeEmitter::emitGetFieldPopSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopSint16, A0, L); } bool ByteCodeEmitter::emitGetFieldPopUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopUint16, A0, L); } bool ByteCodeEmitter::emitGetFieldPopSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopSint32, A0, L); } bool ByteCodeEmitter::emitGetFieldPopUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopUint32, A0, L); } bool ByteCodeEmitter::emitGetFieldPopSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopSint64, A0, L); } bool ByteCodeEmitter::emitGetFieldPopUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopUint64, A0, L); } bool ByteCodeEmitter::emitGetFieldPopIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopIntAP, A0, L); } bool ByteCodeEmitter::emitGetFieldPopIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopIntAPS, A0, L); } bool ByteCodeEmitter::emitGetFieldPopBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopBool, A0, L); } bool ByteCodeEmitter::emitGetFieldPopFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopFixedPoint, A0, L); } bool ByteCodeEmitter::emitGetFieldPopPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopPtr, A0, L); } bool ByteCodeEmitter::emitGetFieldPopMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopMemberPtr, A0, L); } bool ByteCodeEmitter::emitGetFieldPopFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetFieldPopFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetFieldPopSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } bool EvalEmitter::emitGetFieldPopFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFieldPop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetFnPtr, #endif #ifdef GET_INTERP case OP_GetFnPtr: { const auto V0 = ReadArg(S, PC); if (!GetFnPtr(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetFnPtr: Text.Op = PrintName("GetFnPtr"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetFnPtr( const Function * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetFnPtr( const Function * A0, const SourceInfo &L) { return emitOp(OP_GetFnPtr, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetFnPtr( const Function * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetFnPtr(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetGlobalSint8, OP_GetGlobalUint8, OP_GetGlobalSint16, OP_GetGlobalUint16, OP_GetGlobalSint32, OP_GetGlobalUint32, OP_GetGlobalSint64, OP_GetGlobalUint64, OP_GetGlobalIntAP, OP_GetGlobalIntAPS, OP_GetGlobalBool, OP_GetGlobalFixedPoint, OP_GetGlobalPtr, OP_GetGlobalMemberPtr, OP_GetGlobalFloat, #endif #ifdef GET_INTERP case OP_GetGlobalSint8: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUint8: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalSint16: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUint16: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalSint32: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUint32: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalSint64: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUint64: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalIntAP: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalIntAPS: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalBool: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalFixedPoint: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalPtr: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalMemberPtr: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } case OP_GetGlobalFloat: { const auto V0 = ReadArg(S, PC); if (!GetGlobal(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetGlobalSint8: Text.Op = PrintName("GetGlobalSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUint8: Text.Op = PrintName("GetGlobalUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalSint16: Text.Op = PrintName("GetGlobalSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUint16: Text.Op = PrintName("GetGlobalUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalSint32: Text.Op = PrintName("GetGlobalSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUint32: Text.Op = PrintName("GetGlobalUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalSint64: Text.Op = PrintName("GetGlobalSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUint64: Text.Op = PrintName("GetGlobalUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalIntAP: Text.Op = PrintName("GetGlobalIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalIntAPS: Text.Op = PrintName("GetGlobalIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalBool: Text.Op = PrintName("GetGlobalBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalFixedPoint: Text.Op = PrintName("GetGlobalFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalPtr: Text.Op = PrintName("GetGlobalPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalMemberPtr: Text.Op = PrintName("GetGlobalMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalFloat: Text.Op = PrintName("GetGlobalFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetGlobalSint8( uint32_t , const SourceInfo &); bool emitGetGlobalUint8( uint32_t , const SourceInfo &); bool emitGetGlobalSint16( uint32_t , const SourceInfo &); bool emitGetGlobalUint16( uint32_t , const SourceInfo &); bool emitGetGlobalSint32( uint32_t , const SourceInfo &); bool emitGetGlobalUint32( uint32_t , const SourceInfo &); bool emitGetGlobalSint64( uint32_t , const SourceInfo &); bool emitGetGlobalUint64( uint32_t , const SourceInfo &); bool emitGetGlobalIntAP( uint32_t , const SourceInfo &); bool emitGetGlobalIntAPS( uint32_t , const SourceInfo &); bool emitGetGlobalBool( uint32_t , const SourceInfo &); bool emitGetGlobalFixedPoint( uint32_t , const SourceInfo &); bool emitGetGlobalPtr( uint32_t , const SourceInfo &); bool emitGetGlobalMemberPtr( uint32_t , const SourceInfo &); bool emitGetGlobalFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGetGlobal(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGetGlobal(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitGetGlobalSint8(A0, I); case PT_Uint8: return emitGetGlobalUint8(A0, I); case PT_Sint16: return emitGetGlobalSint16(A0, I); case PT_Uint16: return emitGetGlobalUint16(A0, I); case PT_Sint32: return emitGetGlobalSint32(A0, I); case PT_Uint32: return emitGetGlobalUint32(A0, I); case PT_Sint64: return emitGetGlobalSint64(A0, I); case PT_Uint64: return emitGetGlobalUint64(A0, I); case PT_IntAP: return emitGetGlobalIntAP(A0, I); case PT_IntAPS: return emitGetGlobalIntAPS(A0, I); case PT_Bool: return emitGetGlobalBool(A0, I); case PT_FixedPoint: return emitGetGlobalFixedPoint(A0, I); case PT_Ptr: return emitGetGlobalPtr(A0, I); case PT_MemberPtr: return emitGetGlobalMemberPtr(A0, I); case PT_Float: return emitGetGlobalFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetGlobalSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalSint8, A0, L); } bool ByteCodeEmitter::emitGetGlobalUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUint8, A0, L); } bool ByteCodeEmitter::emitGetGlobalSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalSint16, A0, L); } bool ByteCodeEmitter::emitGetGlobalUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUint16, A0, L); } bool ByteCodeEmitter::emitGetGlobalSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalSint32, A0, L); } bool ByteCodeEmitter::emitGetGlobalUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUint32, A0, L); } bool ByteCodeEmitter::emitGetGlobalSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalSint64, A0, L); } bool ByteCodeEmitter::emitGetGlobalUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUint64, A0, L); } bool ByteCodeEmitter::emitGetGlobalIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalIntAP, A0, L); } bool ByteCodeEmitter::emitGetGlobalIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalIntAPS, A0, L); } bool ByteCodeEmitter::emitGetGlobalBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalBool, A0, L); } bool ByteCodeEmitter::emitGetGlobalFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalFixedPoint, A0, L); } bool ByteCodeEmitter::emitGetGlobalPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalPtr, A0, L); } bool ByteCodeEmitter::emitGetGlobalMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalMemberPtr, A0, L); } bool ByteCodeEmitter::emitGetGlobalFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetGlobalSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobal(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetGlobalUncheckedSint8, OP_GetGlobalUncheckedUint8, OP_GetGlobalUncheckedSint16, OP_GetGlobalUncheckedUint16, OP_GetGlobalUncheckedSint32, OP_GetGlobalUncheckedUint32, OP_GetGlobalUncheckedSint64, OP_GetGlobalUncheckedUint64, OP_GetGlobalUncheckedIntAP, OP_GetGlobalUncheckedIntAPS, OP_GetGlobalUncheckedBool, OP_GetGlobalUncheckedFixedPoint, OP_GetGlobalUncheckedPtr, OP_GetGlobalUncheckedMemberPtr, OP_GetGlobalUncheckedFloat, #endif #ifdef GET_INTERP case OP_GetGlobalUncheckedSint8: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedUint8: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedSint16: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedUint16: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedSint32: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedUint32: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedSint64: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedUint64: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedIntAP: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedIntAPS: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedBool: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedFixedPoint: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedPtr: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedMemberPtr: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } case OP_GetGlobalUncheckedFloat: { const auto V0 = ReadArg(S, PC); if (!GetGlobalUnchecked(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetGlobalUncheckedSint8: Text.Op = PrintName("GetGlobalUncheckedSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedUint8: Text.Op = PrintName("GetGlobalUncheckedUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedSint16: Text.Op = PrintName("GetGlobalUncheckedSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedUint16: Text.Op = PrintName("GetGlobalUncheckedUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedSint32: Text.Op = PrintName("GetGlobalUncheckedSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedUint32: Text.Op = PrintName("GetGlobalUncheckedUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedSint64: Text.Op = PrintName("GetGlobalUncheckedSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedUint64: Text.Op = PrintName("GetGlobalUncheckedUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedIntAP: Text.Op = PrintName("GetGlobalUncheckedIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedIntAPS: Text.Op = PrintName("GetGlobalUncheckedIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedBool: Text.Op = PrintName("GetGlobalUncheckedBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedFixedPoint: Text.Op = PrintName("GetGlobalUncheckedFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedPtr: Text.Op = PrintName("GetGlobalUncheckedPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedMemberPtr: Text.Op = PrintName("GetGlobalUncheckedMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetGlobalUncheckedFloat: Text.Op = PrintName("GetGlobalUncheckedFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetGlobalUncheckedSint8( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedUint8( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedSint16( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedUint16( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedSint32( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedUint32( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedSint64( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedUint64( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedIntAP( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedIntAPS( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedBool( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedFixedPoint( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedPtr( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedMemberPtr( uint32_t , const SourceInfo &); bool emitGetGlobalUncheckedFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGetGlobalUnchecked(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGetGlobalUnchecked(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitGetGlobalUncheckedSint8(A0, I); case PT_Uint8: return emitGetGlobalUncheckedUint8(A0, I); case PT_Sint16: return emitGetGlobalUncheckedSint16(A0, I); case PT_Uint16: return emitGetGlobalUncheckedUint16(A0, I); case PT_Sint32: return emitGetGlobalUncheckedSint32(A0, I); case PT_Uint32: return emitGetGlobalUncheckedUint32(A0, I); case PT_Sint64: return emitGetGlobalUncheckedSint64(A0, I); case PT_Uint64: return emitGetGlobalUncheckedUint64(A0, I); case PT_IntAP: return emitGetGlobalUncheckedIntAP(A0, I); case PT_IntAPS: return emitGetGlobalUncheckedIntAPS(A0, I); case PT_Bool: return emitGetGlobalUncheckedBool(A0, I); case PT_FixedPoint: return emitGetGlobalUncheckedFixedPoint(A0, I); case PT_Ptr: return emitGetGlobalUncheckedPtr(A0, I); case PT_MemberPtr: return emitGetGlobalUncheckedMemberPtr(A0, I); case PT_Float: return emitGetGlobalUncheckedFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetGlobalUncheckedSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedSint8, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedUint8, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedSint16, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedUint16, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedSint32, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedUint32, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedSint64, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedUint64, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedIntAP, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedIntAPS, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedBool, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedFixedPoint, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedPtr, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedMemberPtr, A0, L); } bool ByteCodeEmitter::emitGetGlobalUncheckedFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetGlobalUncheckedFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetGlobalUncheckedSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } bool EvalEmitter::emitGetGlobalUncheckedFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetGlobalUnchecked(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetIntPtrSint8, OP_GetIntPtrUint8, OP_GetIntPtrSint16, OP_GetIntPtrUint16, OP_GetIntPtrSint32, OP_GetIntPtrUint32, OP_GetIntPtrSint64, OP_GetIntPtrUint64, OP_GetIntPtrIntAP, OP_GetIntPtrIntAPS, OP_GetIntPtrBool, OP_GetIntPtrFixedPoint, #endif #ifdef GET_INTERP case OP_GetIntPtrSint8: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrUint8: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrSint16: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrUint16: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrSint32: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrUint32: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrSint64: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrUint64: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrIntAP: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrIntAPS: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrBool: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } case OP_GetIntPtrFixedPoint: { const auto V0 = ReadArg(S, PC); if (!GetIntPtr(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetIntPtrSint8: Text.Op = PrintName("GetIntPtrSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrUint8: Text.Op = PrintName("GetIntPtrUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrSint16: Text.Op = PrintName("GetIntPtrSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrUint16: Text.Op = PrintName("GetIntPtrUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrSint32: Text.Op = PrintName("GetIntPtrSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrUint32: Text.Op = PrintName("GetIntPtrUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrSint64: Text.Op = PrintName("GetIntPtrSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrUint64: Text.Op = PrintName("GetIntPtrUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrIntAP: Text.Op = PrintName("GetIntPtrIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrIntAPS: Text.Op = PrintName("GetIntPtrIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrBool: Text.Op = PrintName("GetIntPtrBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetIntPtrFixedPoint: Text.Op = PrintName("GetIntPtrFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetIntPtrSint8( const Descriptor * , const SourceInfo &); bool emitGetIntPtrUint8( const Descriptor * , const SourceInfo &); bool emitGetIntPtrSint16( const Descriptor * , const SourceInfo &); bool emitGetIntPtrUint16( const Descriptor * , const SourceInfo &); bool emitGetIntPtrSint32( const Descriptor * , const SourceInfo &); bool emitGetIntPtrUint32( const Descriptor * , const SourceInfo &); bool emitGetIntPtrSint64( const Descriptor * , const SourceInfo &); bool emitGetIntPtrUint64( const Descriptor * , const SourceInfo &); bool emitGetIntPtrIntAP( const Descriptor * , const SourceInfo &); bool emitGetIntPtrIntAPS( const Descriptor * , const SourceInfo &); bool emitGetIntPtrBool( const Descriptor * , const SourceInfo &); bool emitGetIntPtrFixedPoint( const Descriptor * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGetIntPtr(PrimType, const Descriptor *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGetIntPtr(PrimType T0, const Descriptor * A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitGetIntPtrSint8(A0, I); case PT_Uint8: return emitGetIntPtrUint8(A0, I); case PT_Sint16: return emitGetIntPtrSint16(A0, I); case PT_Uint16: return emitGetIntPtrUint16(A0, I); case PT_Sint32: return emitGetIntPtrSint32(A0, I); case PT_Uint32: return emitGetIntPtrUint32(A0, I); case PT_Sint64: return emitGetIntPtrSint64(A0, I); case PT_Uint64: return emitGetIntPtrUint64(A0, I); case PT_IntAP: return emitGetIntPtrIntAP(A0, I); case PT_IntAPS: return emitGetIntPtrIntAPS(A0, I); case PT_Bool: return emitGetIntPtrBool(A0, I); case PT_FixedPoint: return emitGetIntPtrFixedPoint(A0, I); default: llvm_unreachable("invalid type: emitGetIntPtr"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetIntPtrSint8( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrSint8, A0, L); } bool ByteCodeEmitter::emitGetIntPtrUint8( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrUint8, A0, L); } bool ByteCodeEmitter::emitGetIntPtrSint16( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrSint16, A0, L); } bool ByteCodeEmitter::emitGetIntPtrUint16( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrUint16, A0, L); } bool ByteCodeEmitter::emitGetIntPtrSint32( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrSint32, A0, L); } bool ByteCodeEmitter::emitGetIntPtrUint32( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrUint32, A0, L); } bool ByteCodeEmitter::emitGetIntPtrSint64( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrSint64, A0, L); } bool ByteCodeEmitter::emitGetIntPtrUint64( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrUint64, A0, L); } bool ByteCodeEmitter::emitGetIntPtrIntAP( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrIntAP, A0, L); } bool ByteCodeEmitter::emitGetIntPtrIntAPS( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrIntAPS, A0, L); } bool ByteCodeEmitter::emitGetIntPtrBool( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrBool, A0, L); } bool ByteCodeEmitter::emitGetIntPtrFixedPoint( const Descriptor * A0, const SourceInfo &L) { return emitOp(OP_GetIntPtrFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetIntPtrSint8( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrUint8( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrSint16( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrUint16( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrSint32( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrUint32( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrSint64( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrUint64( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrIntAP( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrIntAPS( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrBool( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } bool EvalEmitter::emitGetIntPtrFixedPoint( const Descriptor * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetIntPtr(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetLocalSint8, OP_GetLocalUint8, OP_GetLocalSint16, OP_GetLocalUint16, OP_GetLocalSint32, OP_GetLocalUint32, OP_GetLocalSint64, OP_GetLocalUint64, OP_GetLocalIntAP, OP_GetLocalIntAPS, OP_GetLocalBool, OP_GetLocalFixedPoint, OP_GetLocalPtr, OP_GetLocalMemberPtr, OP_GetLocalFloat, #endif #ifdef GET_INTERP case OP_GetLocalSint8: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalUint8: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalSint16: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalUint16: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalSint32: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalUint32: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalSint64: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalUint64: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalIntAP: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalIntAPS: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalBool: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalFixedPoint: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalPtr: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalMemberPtr: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } case OP_GetLocalFloat: { const auto V0 = ReadArg(S, PC); if (!GetLocal(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetLocalSint8: Text.Op = PrintName("GetLocalSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalUint8: Text.Op = PrintName("GetLocalUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalSint16: Text.Op = PrintName("GetLocalSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalUint16: Text.Op = PrintName("GetLocalUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalSint32: Text.Op = PrintName("GetLocalSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalUint32: Text.Op = PrintName("GetLocalUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalSint64: Text.Op = PrintName("GetLocalSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalUint64: Text.Op = PrintName("GetLocalUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalIntAP: Text.Op = PrintName("GetLocalIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalIntAPS: Text.Op = PrintName("GetLocalIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalBool: Text.Op = PrintName("GetLocalBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalFixedPoint: Text.Op = PrintName("GetLocalFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalPtr: Text.Op = PrintName("GetLocalPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalMemberPtr: Text.Op = PrintName("GetLocalMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetLocalFloat: Text.Op = PrintName("GetLocalFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetLocalSint8( uint32_t , const SourceInfo &); bool emitGetLocalUint8( uint32_t , const SourceInfo &); bool emitGetLocalSint16( uint32_t , const SourceInfo &); bool emitGetLocalUint16( uint32_t , const SourceInfo &); bool emitGetLocalSint32( uint32_t , const SourceInfo &); bool emitGetLocalUint32( uint32_t , const SourceInfo &); bool emitGetLocalSint64( uint32_t , const SourceInfo &); bool emitGetLocalUint64( uint32_t , const SourceInfo &); bool emitGetLocalIntAP( uint32_t , const SourceInfo &); bool emitGetLocalIntAPS( uint32_t , const SourceInfo &); bool emitGetLocalBool( uint32_t , const SourceInfo &); bool emitGetLocalFixedPoint( uint32_t , const SourceInfo &); bool emitGetLocalPtr( uint32_t , const SourceInfo &); bool emitGetLocalMemberPtr( uint32_t , const SourceInfo &); bool emitGetLocalFloat( uint32_t , const SourceInfo &); #if defined(GET_EVAL_PROTO) template bool emitGetLocal(uint32_t, const SourceInfo &); #endif #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGetLocal(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGetLocal(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: #ifdef GET_LINK_IMPL return emitGetLocalSint8 #else return emitGetLocal #endif (A0, I); case PT_Uint8: #ifdef GET_LINK_IMPL return emitGetLocalUint8 #else return emitGetLocal #endif (A0, I); case PT_Sint16: #ifdef GET_LINK_IMPL return emitGetLocalSint16 #else return emitGetLocal #endif (A0, I); case PT_Uint16: #ifdef GET_LINK_IMPL return emitGetLocalUint16 #else return emitGetLocal #endif (A0, I); case PT_Sint32: #ifdef GET_LINK_IMPL return emitGetLocalSint32 #else return emitGetLocal #endif (A0, I); case PT_Uint32: #ifdef GET_LINK_IMPL return emitGetLocalUint32 #else return emitGetLocal #endif (A0, I); case PT_Sint64: #ifdef GET_LINK_IMPL return emitGetLocalSint64 #else return emitGetLocal #endif (A0, I); case PT_Uint64: #ifdef GET_LINK_IMPL return emitGetLocalUint64 #else return emitGetLocal #endif (A0, I); case PT_IntAP: #ifdef GET_LINK_IMPL return emitGetLocalIntAP #else return emitGetLocal #endif (A0, I); case PT_IntAPS: #ifdef GET_LINK_IMPL return emitGetLocalIntAPS #else return emitGetLocal #endif (A0, I); case PT_Bool: #ifdef GET_LINK_IMPL return emitGetLocalBool #else return emitGetLocal #endif (A0, I); case PT_FixedPoint: #ifdef GET_LINK_IMPL return emitGetLocalFixedPoint #else return emitGetLocal #endif (A0, I); case PT_Ptr: #ifdef GET_LINK_IMPL return emitGetLocalPtr #else return emitGetLocal #endif (A0, I); case PT_MemberPtr: #ifdef GET_LINK_IMPL return emitGetLocalMemberPtr #else return emitGetLocal #endif (A0, I); case PT_Float: #ifdef GET_LINK_IMPL return emitGetLocalFloat #else return emitGetLocal #endif (A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetLocalSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalSint8, A0, L); } bool ByteCodeEmitter::emitGetLocalUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalUint8, A0, L); } bool ByteCodeEmitter::emitGetLocalSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalSint16, A0, L); } bool ByteCodeEmitter::emitGetLocalUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalUint16, A0, L); } bool ByteCodeEmitter::emitGetLocalSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalSint32, A0, L); } bool ByteCodeEmitter::emitGetLocalUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalUint32, A0, L); } bool ByteCodeEmitter::emitGetLocalSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalSint64, A0, L); } bool ByteCodeEmitter::emitGetLocalUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalUint64, A0, L); } bool ByteCodeEmitter::emitGetLocalIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalIntAP, A0, L); } bool ByteCodeEmitter::emitGetLocalIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalIntAPS, A0, L); } bool ByteCodeEmitter::emitGetLocalBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalBool, A0, L); } bool ByteCodeEmitter::emitGetLocalFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalFixedPoint, A0, L); } bool ByteCodeEmitter::emitGetLocalPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalPtr, A0, L); } bool ByteCodeEmitter::emitGetLocalMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalMemberPtr, A0, L); } bool ByteCodeEmitter::emitGetLocalFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetLocalFloat, A0, L); } #endif #ifdef GET_OPCODE_NAMES OP_GetMemberPtr, #endif #ifdef GET_INTERP case OP_GetMemberPtr: { const auto V0 = ReadArg(S, PC); if (!GetMemberPtr(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetMemberPtr: Text.Op = PrintName("GetMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetMemberPtr( const ValueDecl* , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetMemberPtr( const ValueDecl* A0, const SourceInfo &L) { return emitOp(OP_GetMemberPtr, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetMemberPtr( const ValueDecl* A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetMemberPtr(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetMemberPtrBase, #endif #ifdef GET_INTERP case OP_GetMemberPtrBase: { if (!GetMemberPtrBase(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetMemberPtrBase: Text.Op = PrintName("GetMemberPtrBase"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetMemberPtrBase(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetMemberPtrBase(const SourceInfo &L) { return emitOp<>(OP_GetMemberPtrBase, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetMemberPtrBase(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetMemberPtrBase(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_GetMemberPtrBasePop, #endif #ifdef GET_INTERP case OP_GetMemberPtrBasePop: { const auto V0 = ReadArg(S, PC); if (!GetMemberPtrBasePop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetMemberPtrBasePop: Text.Op = PrintName("GetMemberPtrBasePop"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetMemberPtrBasePop( int32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetMemberPtrBasePop( int32_t A0, const SourceInfo &L) { return emitOp(OP_GetMemberPtrBasePop, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetMemberPtrBasePop( int32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetMemberPtrBasePop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetMemberPtrDecl, #endif #ifdef GET_INTERP case OP_GetMemberPtrDecl: { if (!GetMemberPtrDecl(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetMemberPtrDecl: Text.Op = PrintName("GetMemberPtrDecl"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetMemberPtrDecl(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetMemberPtrDecl(const SourceInfo &L) { return emitOp<>(OP_GetMemberPtrDecl, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetMemberPtrDecl(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetMemberPtrDecl(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_GetParamSint8, OP_GetParamUint8, OP_GetParamSint16, OP_GetParamUint16, OP_GetParamSint32, OP_GetParamUint32, OP_GetParamSint64, OP_GetParamUint64, OP_GetParamIntAP, OP_GetParamIntAPS, OP_GetParamBool, OP_GetParamFixedPoint, OP_GetParamPtr, OP_GetParamMemberPtr, OP_GetParamFloat, #endif #ifdef GET_INTERP case OP_GetParamSint8: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamUint8: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamSint16: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamUint16: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamSint32: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamUint32: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamSint64: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamUint64: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamIntAP: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamIntAPS: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamBool: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamFixedPoint: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamPtr: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamMemberPtr: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } case OP_GetParamFloat: { const auto V0 = ReadArg(S, PC); if (!GetParam(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetParamSint8: Text.Op = PrintName("GetParamSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamUint8: Text.Op = PrintName("GetParamUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamSint16: Text.Op = PrintName("GetParamSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamUint16: Text.Op = PrintName("GetParamUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamSint32: Text.Op = PrintName("GetParamSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamUint32: Text.Op = PrintName("GetParamUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamSint64: Text.Op = PrintName("GetParamSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamUint64: Text.Op = PrintName("GetParamUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamIntAP: Text.Op = PrintName("GetParamIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamIntAPS: Text.Op = PrintName("GetParamIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamBool: Text.Op = PrintName("GetParamBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamFixedPoint: Text.Op = PrintName("GetParamFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamPtr: Text.Op = PrintName("GetParamPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamMemberPtr: Text.Op = PrintName("GetParamMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetParamFloat: Text.Op = PrintName("GetParamFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetParamSint8( uint32_t , const SourceInfo &); bool emitGetParamUint8( uint32_t , const SourceInfo &); bool emitGetParamSint16( uint32_t , const SourceInfo &); bool emitGetParamUint16( uint32_t , const SourceInfo &); bool emitGetParamSint32( uint32_t , const SourceInfo &); bool emitGetParamUint32( uint32_t , const SourceInfo &); bool emitGetParamSint64( uint32_t , const SourceInfo &); bool emitGetParamUint64( uint32_t , const SourceInfo &); bool emitGetParamIntAP( uint32_t , const SourceInfo &); bool emitGetParamIntAPS( uint32_t , const SourceInfo &); bool emitGetParamBool( uint32_t , const SourceInfo &); bool emitGetParamFixedPoint( uint32_t , const SourceInfo &); bool emitGetParamPtr( uint32_t , const SourceInfo &); bool emitGetParamMemberPtr( uint32_t , const SourceInfo &); bool emitGetParamFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGetParam(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGetParam(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitGetParamSint8(A0, I); case PT_Uint8: return emitGetParamUint8(A0, I); case PT_Sint16: return emitGetParamSint16(A0, I); case PT_Uint16: return emitGetParamUint16(A0, I); case PT_Sint32: return emitGetParamSint32(A0, I); case PT_Uint32: return emitGetParamUint32(A0, I); case PT_Sint64: return emitGetParamSint64(A0, I); case PT_Uint64: return emitGetParamUint64(A0, I); case PT_IntAP: return emitGetParamIntAP(A0, I); case PT_IntAPS: return emitGetParamIntAPS(A0, I); case PT_Bool: return emitGetParamBool(A0, I); case PT_FixedPoint: return emitGetParamFixedPoint(A0, I); case PT_Ptr: return emitGetParamPtr(A0, I); case PT_MemberPtr: return emitGetParamMemberPtr(A0, I); case PT_Float: return emitGetParamFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetParamSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamSint8, A0, L); } bool ByteCodeEmitter::emitGetParamUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamUint8, A0, L); } bool ByteCodeEmitter::emitGetParamSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamSint16, A0, L); } bool ByteCodeEmitter::emitGetParamUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamUint16, A0, L); } bool ByteCodeEmitter::emitGetParamSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamSint32, A0, L); } bool ByteCodeEmitter::emitGetParamUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamUint32, A0, L); } bool ByteCodeEmitter::emitGetParamSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamSint64, A0, L); } bool ByteCodeEmitter::emitGetParamUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamUint64, A0, L); } bool ByteCodeEmitter::emitGetParamIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamIntAP, A0, L); } bool ByteCodeEmitter::emitGetParamIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamIntAPS, A0, L); } bool ByteCodeEmitter::emitGetParamBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamBool, A0, L); } bool ByteCodeEmitter::emitGetParamFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamFixedPoint, A0, L); } bool ByteCodeEmitter::emitGetParamPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamPtr, A0, L); } bool ByteCodeEmitter::emitGetParamMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamMemberPtr, A0, L); } bool ByteCodeEmitter::emitGetParamFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetParamFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetParamSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } bool EvalEmitter::emitGetParamFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetParam(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrBase, #endif #ifdef GET_INTERP case OP_GetPtrBase: { const auto V0 = ReadArg(S, PC); if (!GetPtrBase(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrBase: Text.Op = PrintName("GetPtrBase"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrBase( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrBase( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetPtrBase, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrBase( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrBase(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrBasePop, #endif #ifdef GET_INTERP case OP_GetPtrBasePop: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!GetPtrBasePop(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrBasePop: Text.Op = PrintName("GetPtrBasePop"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrBasePop( uint32_t , bool , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrBasePop( uint32_t A0, bool A1, const SourceInfo &L) { return emitOp(OP_GetPtrBasePop, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrBasePop( uint32_t A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrBasePop(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrDerivedPop, #endif #ifdef GET_INTERP case OP_GetPtrDerivedPop: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); const auto V2 = ReadArg(S, PC); if (!GetPtrDerivedPop(S, OpPC, V0, V1, V2)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrDerivedPop: Text.Op = PrintName("GetPtrDerivedPop"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrDerivedPop( uint32_t , bool , const Type * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrDerivedPop( uint32_t A0, bool A1, const Type * A2, const SourceInfo &L) { return emitOp(OP_GetPtrDerivedPop, A0, A1, A2, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrDerivedPop( uint32_t A0, bool A1, const Type * A2, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrDerivedPop(S, OpPC, A0, A1, A2); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrField, #endif #ifdef GET_INTERP case OP_GetPtrField: { const auto V0 = ReadArg(S, PC); if (!GetPtrField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrField: Text.Op = PrintName("GetPtrField"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrField( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrField( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetPtrField, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrField( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrFieldPop, #endif #ifdef GET_INTERP case OP_GetPtrFieldPop: { const auto V0 = ReadArg(S, PC); if (!GetPtrFieldPop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrFieldPop: Text.Op = PrintName("GetPtrFieldPop"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrFieldPop( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrFieldPop( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetPtrFieldPop, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrFieldPop( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrFieldPop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrGlobal, #endif #ifdef GET_INTERP case OP_GetPtrGlobal: { const auto V0 = ReadArg(S, PC); if (!GetPtrGlobal(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrGlobal: Text.Op = PrintName("GetPtrGlobal"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrGlobal( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrGlobal( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetPtrGlobal, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrGlobal( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrGlobal(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrLocal, #endif #ifdef GET_INTERP case OP_GetPtrLocal: { const auto V0 = ReadArg(S, PC); if (!GetPtrLocal(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrLocal: Text.Op = PrintName("GetPtrLocal"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrLocal( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrLocal( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetPtrLocal, A0, L); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrParam, #endif #ifdef GET_INTERP case OP_GetPtrParam: { const auto V0 = ReadArg(S, PC); if (!GetPtrParam(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrParam: Text.Op = PrintName("GetPtrParam"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrParam( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrParam( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetPtrParam, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrParam( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrParam(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrThisBase, #endif #ifdef GET_INTERP case OP_GetPtrThisBase: { const auto V0 = ReadArg(S, PC); if (!GetPtrThisBase(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrThisBase: Text.Op = PrintName("GetPtrThisBase"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrThisBase( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrThisBase( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetPtrThisBase, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrThisBase( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrThisBase(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrThisField, #endif #ifdef GET_INTERP case OP_GetPtrThisField: { const auto V0 = ReadArg(S, PC); if (!GetPtrThisField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrThisField: Text.Op = PrintName("GetPtrThisField"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrThisField( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrThisField( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetPtrThisField, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrThisField( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrThisField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrThisVirtBase, #endif #ifdef GET_INTERP case OP_GetPtrThisVirtBase: { const auto V0 = ReadArg(S, PC); if (!GetPtrThisVirtBase(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrThisVirtBase: Text.Op = PrintName("GetPtrThisVirtBase"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrThisVirtBase( const RecordDecl * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrThisVirtBase( const RecordDecl * A0, const SourceInfo &L) { return emitOp(OP_GetPtrThisVirtBase, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrThisVirtBase( const RecordDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrThisVirtBase(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetPtrVirtBasePop, #endif #ifdef GET_INTERP case OP_GetPtrVirtBasePop: { const auto V0 = ReadArg(S, PC); if (!GetPtrVirtBasePop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetPtrVirtBasePop: Text.Op = PrintName("GetPtrVirtBasePop"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetPtrVirtBasePop( const RecordDecl * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetPtrVirtBasePop( const RecordDecl * A0, const SourceInfo &L) { return emitOp(OP_GetPtrVirtBasePop, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetPtrVirtBasePop( const RecordDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetPtrVirtBasePop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetThisFieldSint8, OP_GetThisFieldUint8, OP_GetThisFieldSint16, OP_GetThisFieldUint16, OP_GetThisFieldSint32, OP_GetThisFieldUint32, OP_GetThisFieldSint64, OP_GetThisFieldUint64, OP_GetThisFieldIntAP, OP_GetThisFieldIntAPS, OP_GetThisFieldBool, OP_GetThisFieldFixedPoint, OP_GetThisFieldPtr, OP_GetThisFieldMemberPtr, OP_GetThisFieldFloat, #endif #ifdef GET_INTERP case OP_GetThisFieldSint8: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldUint8: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldSint16: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldUint16: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldSint32: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldUint32: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldSint64: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldUint64: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldIntAP: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldIntAPS: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldBool: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldFixedPoint: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldPtr: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldMemberPtr: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } case OP_GetThisFieldFloat: { const auto V0 = ReadArg(S, PC); if (!GetThisField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetThisFieldSint8: Text.Op = PrintName("GetThisFieldSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldUint8: Text.Op = PrintName("GetThisFieldUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldSint16: Text.Op = PrintName("GetThisFieldSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldUint16: Text.Op = PrintName("GetThisFieldUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldSint32: Text.Op = PrintName("GetThisFieldSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldUint32: Text.Op = PrintName("GetThisFieldUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldSint64: Text.Op = PrintName("GetThisFieldSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldUint64: Text.Op = PrintName("GetThisFieldUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldIntAP: Text.Op = PrintName("GetThisFieldIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldIntAPS: Text.Op = PrintName("GetThisFieldIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldBool: Text.Op = PrintName("GetThisFieldBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldFixedPoint: Text.Op = PrintName("GetThisFieldFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldPtr: Text.Op = PrintName("GetThisFieldPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldMemberPtr: Text.Op = PrintName("GetThisFieldMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_GetThisFieldFloat: Text.Op = PrintName("GetThisFieldFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetThisFieldSint8( uint32_t , const SourceInfo &); bool emitGetThisFieldUint8( uint32_t , const SourceInfo &); bool emitGetThisFieldSint16( uint32_t , const SourceInfo &); bool emitGetThisFieldUint16( uint32_t , const SourceInfo &); bool emitGetThisFieldSint32( uint32_t , const SourceInfo &); bool emitGetThisFieldUint32( uint32_t , const SourceInfo &); bool emitGetThisFieldSint64( uint32_t , const SourceInfo &); bool emitGetThisFieldUint64( uint32_t , const SourceInfo &); bool emitGetThisFieldIntAP( uint32_t , const SourceInfo &); bool emitGetThisFieldIntAPS( uint32_t , const SourceInfo &); bool emitGetThisFieldBool( uint32_t , const SourceInfo &); bool emitGetThisFieldFixedPoint( uint32_t , const SourceInfo &); bool emitGetThisFieldPtr( uint32_t , const SourceInfo &); bool emitGetThisFieldMemberPtr( uint32_t , const SourceInfo &); bool emitGetThisFieldFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitGetThisField(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitGetThisField(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitGetThisFieldSint8(A0, I); case PT_Uint8: return emitGetThisFieldUint8(A0, I); case PT_Sint16: return emitGetThisFieldSint16(A0, I); case PT_Uint16: return emitGetThisFieldUint16(A0, I); case PT_Sint32: return emitGetThisFieldSint32(A0, I); case PT_Uint32: return emitGetThisFieldUint32(A0, I); case PT_Sint64: return emitGetThisFieldSint64(A0, I); case PT_Uint64: return emitGetThisFieldUint64(A0, I); case PT_IntAP: return emitGetThisFieldIntAP(A0, I); case PT_IntAPS: return emitGetThisFieldIntAPS(A0, I); case PT_Bool: return emitGetThisFieldBool(A0, I); case PT_FixedPoint: return emitGetThisFieldFixedPoint(A0, I); case PT_Ptr: return emitGetThisFieldPtr(A0, I); case PT_MemberPtr: return emitGetThisFieldMemberPtr(A0, I); case PT_Float: return emitGetThisFieldFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetThisFieldSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldSint8, A0, L); } bool ByteCodeEmitter::emitGetThisFieldUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldUint8, A0, L); } bool ByteCodeEmitter::emitGetThisFieldSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldSint16, A0, L); } bool ByteCodeEmitter::emitGetThisFieldUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldUint16, A0, L); } bool ByteCodeEmitter::emitGetThisFieldSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldSint32, A0, L); } bool ByteCodeEmitter::emitGetThisFieldUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldUint32, A0, L); } bool ByteCodeEmitter::emitGetThisFieldSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldSint64, A0, L); } bool ByteCodeEmitter::emitGetThisFieldUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldUint64, A0, L); } bool ByteCodeEmitter::emitGetThisFieldIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldIntAP, A0, L); } bool ByteCodeEmitter::emitGetThisFieldIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldIntAPS, A0, L); } bool ByteCodeEmitter::emitGetThisFieldBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldBool, A0, L); } bool ByteCodeEmitter::emitGetThisFieldFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldFixedPoint, A0, L); } bool ByteCodeEmitter::emitGetThisFieldPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldPtr, A0, L); } bool ByteCodeEmitter::emitGetThisFieldMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldMemberPtr, A0, L); } bool ByteCodeEmitter::emitGetThisFieldFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_GetThisFieldFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetThisFieldSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } bool EvalEmitter::emitGetThisFieldFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetThisField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_GetTypeid, #endif #ifdef GET_INTERP case OP_GetTypeid: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!GetTypeid(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetTypeid: Text.Op = PrintName("GetTypeid"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetTypeid( const Type * , const Type * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetTypeid( const Type * A0, const Type * A1, const SourceInfo &L) { return emitOp(OP_GetTypeid, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetTypeid( const Type * A0, const Type * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetTypeid(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_GetTypeidPtr, #endif #ifdef GET_INTERP case OP_GetTypeidPtr: { const auto V0 = ReadArg(S, PC); if (!GetTypeidPtr(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_GetTypeidPtr: Text.Op = PrintName("GetTypeidPtr"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitGetTypeidPtr( const Type * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitGetTypeidPtr( const Type * A0, const SourceInfo &L) { return emitOp(OP_GetTypeidPtr, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitGetTypeidPtr( const Type * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return GetTypeidPtr(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_IncSint8, OP_IncUint8, OP_IncSint16, OP_IncUint16, OP_IncSint32, OP_IncUint32, OP_IncSint64, OP_IncUint64, OP_IncIntAP, OP_IncIntAPS, OP_IncBool, OP_IncFixedPoint, #endif #ifdef GET_INTERP case OP_IncSint8: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncUint8: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncSint16: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncUint16: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncSint32: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncUint32: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncSint64: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncUint64: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncIntAP: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncIntAPS: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncBool: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } case OP_IncFixedPoint: { const auto V0 = ReadArg(S, PC); if (!Inc(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_IncSint8: Text.Op = PrintName("IncSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncUint8: Text.Op = PrintName("IncUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncSint16: Text.Op = PrintName("IncSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncUint16: Text.Op = PrintName("IncUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncSint32: Text.Op = PrintName("IncSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncUint32: Text.Op = PrintName("IncUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncSint64: Text.Op = PrintName("IncSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncUint64: Text.Op = PrintName("IncUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncIntAP: Text.Op = PrintName("IncIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncIntAPS: Text.Op = PrintName("IncIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncBool: Text.Op = PrintName("IncBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncFixedPoint: Text.Op = PrintName("IncFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitIncSint8( bool , const SourceInfo &); bool emitIncUint8( bool , const SourceInfo &); bool emitIncSint16( bool , const SourceInfo &); bool emitIncUint16( bool , const SourceInfo &); bool emitIncSint32( bool , const SourceInfo &); bool emitIncUint32( bool , const SourceInfo &); bool emitIncSint64( bool , const SourceInfo &); bool emitIncUint64( bool , const SourceInfo &); bool emitIncIntAP( bool , const SourceInfo &); bool emitIncIntAPS( bool , const SourceInfo &); bool emitIncBool( bool , const SourceInfo &); bool emitIncFixedPoint( bool , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInc(PrimType, bool, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInc(PrimType T0, bool A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitIncSint8(A0, I); case PT_Uint8: return emitIncUint8(A0, I); case PT_Sint16: return emitIncSint16(A0, I); case PT_Uint16: return emitIncUint16(A0, I); case PT_Sint32: return emitIncSint32(A0, I); case PT_Uint32: return emitIncUint32(A0, I); case PT_Sint64: return emitIncSint64(A0, I); case PT_Uint64: return emitIncUint64(A0, I); case PT_IntAP: return emitIncIntAP(A0, I); case PT_IntAPS: return emitIncIntAPS(A0, I); case PT_Bool: return emitIncBool(A0, I); case PT_FixedPoint: return emitIncFixedPoint(A0, I); default: llvm_unreachable("invalid type: emitInc"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitIncSint8( bool A0, const SourceInfo &L) { return emitOp(OP_IncSint8, A0, L); } bool ByteCodeEmitter::emitIncUint8( bool A0, const SourceInfo &L) { return emitOp(OP_IncUint8, A0, L); } bool ByteCodeEmitter::emitIncSint16( bool A0, const SourceInfo &L) { return emitOp(OP_IncSint16, A0, L); } bool ByteCodeEmitter::emitIncUint16( bool A0, const SourceInfo &L) { return emitOp(OP_IncUint16, A0, L); } bool ByteCodeEmitter::emitIncSint32( bool A0, const SourceInfo &L) { return emitOp(OP_IncSint32, A0, L); } bool ByteCodeEmitter::emitIncUint32( bool A0, const SourceInfo &L) { return emitOp(OP_IncUint32, A0, L); } bool ByteCodeEmitter::emitIncSint64( bool A0, const SourceInfo &L) { return emitOp(OP_IncSint64, A0, L); } bool ByteCodeEmitter::emitIncUint64( bool A0, const SourceInfo &L) { return emitOp(OP_IncUint64, A0, L); } bool ByteCodeEmitter::emitIncIntAP( bool A0, const SourceInfo &L) { return emitOp(OP_IncIntAP, A0, L); } bool ByteCodeEmitter::emitIncIntAPS( bool A0, const SourceInfo &L) { return emitOp(OP_IncIntAPS, A0, L); } bool ByteCodeEmitter::emitIncBool( bool A0, const SourceInfo &L) { return emitOp(OP_IncBool, A0, L); } bool ByteCodeEmitter::emitIncFixedPoint( bool A0, const SourceInfo &L) { return emitOp(OP_IncFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitIncSint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncUint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncSint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncUint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncSint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncUint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncSint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncUint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncIntAP( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncIntAPS( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncBool( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } bool EvalEmitter::emitIncFixedPoint( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inc(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_IncPopSint8, OP_IncPopUint8, OP_IncPopSint16, OP_IncPopUint16, OP_IncPopSint32, OP_IncPopUint32, OP_IncPopSint64, OP_IncPopUint64, OP_IncPopIntAP, OP_IncPopIntAPS, OP_IncPopBool, OP_IncPopFixedPoint, #endif #ifdef GET_INTERP case OP_IncPopSint8: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopUint8: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopSint16: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopUint16: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopSint32: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopUint32: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopSint64: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopUint64: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopIntAP: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopIntAPS: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopBool: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } case OP_IncPopFixedPoint: { const auto V0 = ReadArg(S, PC); if (!IncPop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_IncPopSint8: Text.Op = PrintName("IncPopSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopUint8: Text.Op = PrintName("IncPopUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopSint16: Text.Op = PrintName("IncPopSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopUint16: Text.Op = PrintName("IncPopUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopSint32: Text.Op = PrintName("IncPopSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopUint32: Text.Op = PrintName("IncPopUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopSint64: Text.Op = PrintName("IncPopSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopUint64: Text.Op = PrintName("IncPopUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopIntAP: Text.Op = PrintName("IncPopIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopIntAPS: Text.Op = PrintName("IncPopIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopBool: Text.Op = PrintName("IncPopBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_IncPopFixedPoint: Text.Op = PrintName("IncPopFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitIncPopSint8( bool , const SourceInfo &); bool emitIncPopUint8( bool , const SourceInfo &); bool emitIncPopSint16( bool , const SourceInfo &); bool emitIncPopUint16( bool , const SourceInfo &); bool emitIncPopSint32( bool , const SourceInfo &); bool emitIncPopUint32( bool , const SourceInfo &); bool emitIncPopSint64( bool , const SourceInfo &); bool emitIncPopUint64( bool , const SourceInfo &); bool emitIncPopIntAP( bool , const SourceInfo &); bool emitIncPopIntAPS( bool , const SourceInfo &); bool emitIncPopBool( bool , const SourceInfo &); bool emitIncPopFixedPoint( bool , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitIncPop(PrimType, bool, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitIncPop(PrimType T0, bool A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitIncPopSint8(A0, I); case PT_Uint8: return emitIncPopUint8(A0, I); case PT_Sint16: return emitIncPopSint16(A0, I); case PT_Uint16: return emitIncPopUint16(A0, I); case PT_Sint32: return emitIncPopSint32(A0, I); case PT_Uint32: return emitIncPopUint32(A0, I); case PT_Sint64: return emitIncPopSint64(A0, I); case PT_Uint64: return emitIncPopUint64(A0, I); case PT_IntAP: return emitIncPopIntAP(A0, I); case PT_IntAPS: return emitIncPopIntAPS(A0, I); case PT_Bool: return emitIncPopBool(A0, I); case PT_FixedPoint: return emitIncPopFixedPoint(A0, I); default: llvm_unreachable("invalid type: emitIncPop"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitIncPopSint8( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopSint8, A0, L); } bool ByteCodeEmitter::emitIncPopUint8( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopUint8, A0, L); } bool ByteCodeEmitter::emitIncPopSint16( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopSint16, A0, L); } bool ByteCodeEmitter::emitIncPopUint16( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopUint16, A0, L); } bool ByteCodeEmitter::emitIncPopSint32( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopSint32, A0, L); } bool ByteCodeEmitter::emitIncPopUint32( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopUint32, A0, L); } bool ByteCodeEmitter::emitIncPopSint64( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopSint64, A0, L); } bool ByteCodeEmitter::emitIncPopUint64( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopUint64, A0, L); } bool ByteCodeEmitter::emitIncPopIntAP( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopIntAP, A0, L); } bool ByteCodeEmitter::emitIncPopIntAPS( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopIntAPS, A0, L); } bool ByteCodeEmitter::emitIncPopBool( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopBool, A0, L); } bool ByteCodeEmitter::emitIncPopFixedPoint( bool A0, const SourceInfo &L) { return emitOp(OP_IncPopFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitIncPopSint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopUint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopSint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopUint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopSint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopUint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopSint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopUint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopIntAP( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopIntAPS( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopBool( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } bool EvalEmitter::emitIncPopFixedPoint( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_IncPtr, #endif #ifdef GET_INTERP case OP_IncPtr: { if (!IncPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_IncPtr: Text.Op = PrintName("IncPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitIncPtr(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitIncPtr(const SourceInfo &L) { return emitOp<>(OP_IncPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitIncPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Incf, #endif #ifdef GET_INTERP case OP_Incf: { const auto V0 = ReadArg(S, PC); if (!Incf(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Incf: Text.Op = PrintName("Incf"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitIncf( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitIncf( uint32_t A0, const SourceInfo &L) { return emitOp(OP_Incf, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitIncf( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Incf(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_IncfPop, #endif #ifdef GET_INTERP case OP_IncfPop: { const auto V0 = ReadArg(S, PC); if (!IncfPop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_IncfPop: Text.Op = PrintName("IncfPop"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitIncfPop( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitIncfPop( uint32_t A0, const SourceInfo &L) { return emitOp(OP_IncfPop, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitIncfPop( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IncfPop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitSint8, OP_InitUint8, OP_InitSint16, OP_InitUint16, OP_InitSint32, OP_InitUint32, OP_InitSint64, OP_InitUint64, OP_InitIntAP, OP_InitIntAPS, OP_InitBool, OP_InitFixedPoint, OP_InitPtr, OP_InitMemberPtr, OP_InitFloat, #endif #ifdef GET_INTERP case OP_InitSint8: { if (!Init(S, OpPC)) return false; continue; } case OP_InitUint8: { if (!Init(S, OpPC)) return false; continue; } case OP_InitSint16: { if (!Init(S, OpPC)) return false; continue; } case OP_InitUint16: { if (!Init(S, OpPC)) return false; continue; } case OP_InitSint32: { if (!Init(S, OpPC)) return false; continue; } case OP_InitUint32: { if (!Init(S, OpPC)) return false; continue; } case OP_InitSint64: { if (!Init(S, OpPC)) return false; continue; } case OP_InitUint64: { if (!Init(S, OpPC)) return false; continue; } case OP_InitIntAP: { if (!Init(S, OpPC)) return false; continue; } case OP_InitIntAPS: { if (!Init(S, OpPC)) return false; continue; } case OP_InitBool: { if (!Init(S, OpPC)) return false; continue; } case OP_InitFixedPoint: { if (!Init(S, OpPC)) return false; continue; } case OP_InitPtr: { if (!Init(S, OpPC)) return false; continue; } case OP_InitMemberPtr: { if (!Init(S, OpPC)) return false; continue; } case OP_InitFloat: { if (!Init(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitSint8: Text.Op = PrintName("InitSint8"); break; case OP_InitUint8: Text.Op = PrintName("InitUint8"); break; case OP_InitSint16: Text.Op = PrintName("InitSint16"); break; case OP_InitUint16: Text.Op = PrintName("InitUint16"); break; case OP_InitSint32: Text.Op = PrintName("InitSint32"); break; case OP_InitUint32: Text.Op = PrintName("InitUint32"); break; case OP_InitSint64: Text.Op = PrintName("InitSint64"); break; case OP_InitUint64: Text.Op = PrintName("InitUint64"); break; case OP_InitIntAP: Text.Op = PrintName("InitIntAP"); break; case OP_InitIntAPS: Text.Op = PrintName("InitIntAPS"); break; case OP_InitBool: Text.Op = PrintName("InitBool"); break; case OP_InitFixedPoint: Text.Op = PrintName("InitFixedPoint"); break; case OP_InitPtr: Text.Op = PrintName("InitPtr"); break; case OP_InitMemberPtr: Text.Op = PrintName("InitMemberPtr"); break; case OP_InitFloat: Text.Op = PrintName("InitFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitSint8(const SourceInfo &); bool emitInitUint8(const SourceInfo &); bool emitInitSint16(const SourceInfo &); bool emitInitUint16(const SourceInfo &); bool emitInitSint32(const SourceInfo &); bool emitInitUint32(const SourceInfo &); bool emitInitSint64(const SourceInfo &); bool emitInitUint64(const SourceInfo &); bool emitInitIntAP(const SourceInfo &); bool emitInitIntAPS(const SourceInfo &); bool emitInitBool(const SourceInfo &); bool emitInitFixedPoint(const SourceInfo &); bool emitInitPtr(const SourceInfo &); bool emitInitMemberPtr(const SourceInfo &); bool emitInitFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInit(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInit(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitSint8(I); case PT_Uint8: return emitInitUint8(I); case PT_Sint16: return emitInitSint16(I); case PT_Uint16: return emitInitUint16(I); case PT_Sint32: return emitInitSint32(I); case PT_Uint32: return emitInitUint32(I); case PT_Sint64: return emitInitSint64(I); case PT_Uint64: return emitInitUint64(I); case PT_IntAP: return emitInitIntAP(I); case PT_IntAPS: return emitInitIntAPS(I); case PT_Bool: return emitInitBool(I); case PT_FixedPoint: return emitInitFixedPoint(I); case PT_Ptr: return emitInitPtr(I); case PT_MemberPtr: return emitInitMemberPtr(I); case PT_Float: return emitInitFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitSint8(const SourceInfo &L) { return emitOp<>(OP_InitSint8, L); } bool ByteCodeEmitter::emitInitUint8(const SourceInfo &L) { return emitOp<>(OP_InitUint8, L); } bool ByteCodeEmitter::emitInitSint16(const SourceInfo &L) { return emitOp<>(OP_InitSint16, L); } bool ByteCodeEmitter::emitInitUint16(const SourceInfo &L) { return emitOp<>(OP_InitUint16, L); } bool ByteCodeEmitter::emitInitSint32(const SourceInfo &L) { return emitOp<>(OP_InitSint32, L); } bool ByteCodeEmitter::emitInitUint32(const SourceInfo &L) { return emitOp<>(OP_InitUint32, L); } bool ByteCodeEmitter::emitInitSint64(const SourceInfo &L) { return emitOp<>(OP_InitSint64, L); } bool ByteCodeEmitter::emitInitUint64(const SourceInfo &L) { return emitOp<>(OP_InitUint64, L); } bool ByteCodeEmitter::emitInitIntAP(const SourceInfo &L) { return emitOp<>(OP_InitIntAP, L); } bool ByteCodeEmitter::emitInitIntAPS(const SourceInfo &L) { return emitOp<>(OP_InitIntAPS, L); } bool ByteCodeEmitter::emitInitBool(const SourceInfo &L) { return emitOp<>(OP_InitBool, L); } bool ByteCodeEmitter::emitInitFixedPoint(const SourceInfo &L) { return emitOp<>(OP_InitFixedPoint, L); } bool ByteCodeEmitter::emitInitPtr(const SourceInfo &L) { return emitOp<>(OP_InitPtr, L); } bool ByteCodeEmitter::emitInitMemberPtr(const SourceInfo &L) { return emitOp<>(OP_InitMemberPtr, L); } bool ByteCodeEmitter::emitInitFloat(const SourceInfo &L) { return emitOp<>(OP_InitFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } bool EvalEmitter::emitInitFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Init(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_InitBitFieldSint8, OP_InitBitFieldUint8, OP_InitBitFieldSint16, OP_InitBitFieldUint16, OP_InitBitFieldSint32, OP_InitBitFieldUint32, OP_InitBitFieldSint64, OP_InitBitFieldUint64, OP_InitBitFieldIntAP, OP_InitBitFieldIntAPS, OP_InitBitFieldBool, #endif #ifdef GET_INTERP case OP_InitBitFieldSint8: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldUint8: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldSint16: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldUint16: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldSint32: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldUint32: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldSint64: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldUint64: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldIntAP: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldIntAPS: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldBool: { const auto V0 = ReadArg(S, PC); if (!InitBitField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitBitFieldSint8: Text.Op = PrintName("InitBitFieldSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldUint8: Text.Op = PrintName("InitBitFieldUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldSint16: Text.Op = PrintName("InitBitFieldSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldUint16: Text.Op = PrintName("InitBitFieldUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldSint32: Text.Op = PrintName("InitBitFieldSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldUint32: Text.Op = PrintName("InitBitFieldUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldSint64: Text.Op = PrintName("InitBitFieldSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldUint64: Text.Op = PrintName("InitBitFieldUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldIntAP: Text.Op = PrintName("InitBitFieldIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldIntAPS: Text.Op = PrintName("InitBitFieldIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldBool: Text.Op = PrintName("InitBitFieldBool"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitBitFieldSint8( const Record::Field * , const SourceInfo &); bool emitInitBitFieldUint8( const Record::Field * , const SourceInfo &); bool emitInitBitFieldSint16( const Record::Field * , const SourceInfo &); bool emitInitBitFieldUint16( const Record::Field * , const SourceInfo &); bool emitInitBitFieldSint32( const Record::Field * , const SourceInfo &); bool emitInitBitFieldUint32( const Record::Field * , const SourceInfo &); bool emitInitBitFieldSint64( const Record::Field * , const SourceInfo &); bool emitInitBitFieldUint64( const Record::Field * , const SourceInfo &); bool emitInitBitFieldIntAP( const Record::Field * , const SourceInfo &); bool emitInitBitFieldIntAPS( const Record::Field * , const SourceInfo &); bool emitInitBitFieldBool( const Record::Field * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitBitField(PrimType, const Record::Field *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitBitField(PrimType T0, const Record::Field * A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitBitFieldSint8(A0, I); case PT_Uint8: return emitInitBitFieldUint8(A0, I); case PT_Sint16: return emitInitBitFieldSint16(A0, I); case PT_Uint16: return emitInitBitFieldUint16(A0, I); case PT_Sint32: return emitInitBitFieldSint32(A0, I); case PT_Uint32: return emitInitBitFieldUint32(A0, I); case PT_Sint64: return emitInitBitFieldSint64(A0, I); case PT_Uint64: return emitInitBitFieldUint64(A0, I); case PT_IntAP: return emitInitBitFieldIntAP(A0, I); case PT_IntAPS: return emitInitBitFieldIntAPS(A0, I); case PT_Bool: return emitInitBitFieldBool(A0, I); default: llvm_unreachable("invalid type: emitInitBitField"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitBitFieldSint8( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldSint8, A0, L); } bool ByteCodeEmitter::emitInitBitFieldUint8( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldUint8, A0, L); } bool ByteCodeEmitter::emitInitBitFieldSint16( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldSint16, A0, L); } bool ByteCodeEmitter::emitInitBitFieldUint16( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldUint16, A0, L); } bool ByteCodeEmitter::emitInitBitFieldSint32( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldSint32, A0, L); } bool ByteCodeEmitter::emitInitBitFieldUint32( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldUint32, A0, L); } bool ByteCodeEmitter::emitInitBitFieldSint64( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldSint64, A0, L); } bool ByteCodeEmitter::emitInitBitFieldUint64( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldUint64, A0, L); } bool ByteCodeEmitter::emitInitBitFieldIntAP( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldIntAP, A0, L); } bool ByteCodeEmitter::emitInitBitFieldIntAPS( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldIntAPS, A0, L); } bool ByteCodeEmitter::emitInitBitFieldBool( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldBool, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitBitFieldSint8( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldUint8( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldSint16( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldUint16( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldSint32( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldUint32( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldSint64( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldUint64( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldIntAP( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldIntAPS( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldBool( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitBitFieldActivateSint8, OP_InitBitFieldActivateUint8, OP_InitBitFieldActivateSint16, OP_InitBitFieldActivateUint16, OP_InitBitFieldActivateSint32, OP_InitBitFieldActivateUint32, OP_InitBitFieldActivateSint64, OP_InitBitFieldActivateUint64, OP_InitBitFieldActivateIntAP, OP_InitBitFieldActivateIntAPS, OP_InitBitFieldActivateBool, #endif #ifdef GET_INTERP case OP_InitBitFieldActivateSint8: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateUint8: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateSint16: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateUint16: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateSint32: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateUint32: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateSint64: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateUint64: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateIntAP: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateIntAPS: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitBitFieldActivateBool: { const auto V0 = ReadArg(S, PC); if (!InitBitFieldActivate(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitBitFieldActivateSint8: Text.Op = PrintName("InitBitFieldActivateSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateUint8: Text.Op = PrintName("InitBitFieldActivateUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateSint16: Text.Op = PrintName("InitBitFieldActivateSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateUint16: Text.Op = PrintName("InitBitFieldActivateUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateSint32: Text.Op = PrintName("InitBitFieldActivateSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateUint32: Text.Op = PrintName("InitBitFieldActivateUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateSint64: Text.Op = PrintName("InitBitFieldActivateSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateUint64: Text.Op = PrintName("InitBitFieldActivateUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateIntAP: Text.Op = PrintName("InitBitFieldActivateIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateIntAPS: Text.Op = PrintName("InitBitFieldActivateIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitBitFieldActivateBool: Text.Op = PrintName("InitBitFieldActivateBool"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitBitFieldActivateSint8( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateUint8( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateSint16( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateUint16( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateSint32( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateUint32( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateSint64( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateUint64( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateIntAP( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateIntAPS( const Record::Field * , const SourceInfo &); bool emitInitBitFieldActivateBool( const Record::Field * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitBitFieldActivate(PrimType, const Record::Field *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitBitFieldActivate(PrimType T0, const Record::Field * A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitBitFieldActivateSint8(A0, I); case PT_Uint8: return emitInitBitFieldActivateUint8(A0, I); case PT_Sint16: return emitInitBitFieldActivateSint16(A0, I); case PT_Uint16: return emitInitBitFieldActivateUint16(A0, I); case PT_Sint32: return emitInitBitFieldActivateSint32(A0, I); case PT_Uint32: return emitInitBitFieldActivateUint32(A0, I); case PT_Sint64: return emitInitBitFieldActivateSint64(A0, I); case PT_Uint64: return emitInitBitFieldActivateUint64(A0, I); case PT_IntAP: return emitInitBitFieldActivateIntAP(A0, I); case PT_IntAPS: return emitInitBitFieldActivateIntAPS(A0, I); case PT_Bool: return emitInitBitFieldActivateBool(A0, I); default: llvm_unreachable("invalid type: emitInitBitFieldActivate"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitBitFieldActivateSint8( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateSint8, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateUint8( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateUint8, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateSint16( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateSint16, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateUint16( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateUint16, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateSint32( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateSint32, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateUint32( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateUint32, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateSint64( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateSint64, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateUint64( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateUint64, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateIntAP( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateIntAP, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateIntAPS( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateIntAPS, A0, L); } bool ByteCodeEmitter::emitInitBitFieldActivateBool( const Record::Field * A0, const SourceInfo &L) { return emitOp(OP_InitBitFieldActivateBool, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitBitFieldActivateSint8( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateUint8( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateSint16( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateUint16( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateSint32( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateUint32( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateSint64( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateUint64( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateIntAP( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateIntAPS( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitBitFieldActivateBool( const Record::Field * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitBitFieldActivate(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitElemSint8, OP_InitElemUint8, OP_InitElemSint16, OP_InitElemUint16, OP_InitElemSint32, OP_InitElemUint32, OP_InitElemSint64, OP_InitElemUint64, OP_InitElemIntAP, OP_InitElemIntAPS, OP_InitElemBool, OP_InitElemFixedPoint, OP_InitElemPtr, OP_InitElemMemberPtr, OP_InitElemFloat, #endif #ifdef GET_INTERP case OP_InitElemSint8: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemUint8: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemSint16: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemUint16: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemSint32: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemUint32: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemSint64: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemUint64: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemIntAP: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemIntAPS: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemBool: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemFixedPoint: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemPtr: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemMemberPtr: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } case OP_InitElemFloat: { const auto V0 = ReadArg(S, PC); if (!InitElem(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitElemSint8: Text.Op = PrintName("InitElemSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemUint8: Text.Op = PrintName("InitElemUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemSint16: Text.Op = PrintName("InitElemSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemUint16: Text.Op = PrintName("InitElemUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemSint32: Text.Op = PrintName("InitElemSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemUint32: Text.Op = PrintName("InitElemUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemSint64: Text.Op = PrintName("InitElemSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemUint64: Text.Op = PrintName("InitElemUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemIntAP: Text.Op = PrintName("InitElemIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemIntAPS: Text.Op = PrintName("InitElemIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemBool: Text.Op = PrintName("InitElemBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemFixedPoint: Text.Op = PrintName("InitElemFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPtr: Text.Op = PrintName("InitElemPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemMemberPtr: Text.Op = PrintName("InitElemMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemFloat: Text.Op = PrintName("InitElemFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitElemSint8( uint32_t , const SourceInfo &); bool emitInitElemUint8( uint32_t , const SourceInfo &); bool emitInitElemSint16( uint32_t , const SourceInfo &); bool emitInitElemUint16( uint32_t , const SourceInfo &); bool emitInitElemSint32( uint32_t , const SourceInfo &); bool emitInitElemUint32( uint32_t , const SourceInfo &); bool emitInitElemSint64( uint32_t , const SourceInfo &); bool emitInitElemUint64( uint32_t , const SourceInfo &); bool emitInitElemIntAP( uint32_t , const SourceInfo &); bool emitInitElemIntAPS( uint32_t , const SourceInfo &); bool emitInitElemBool( uint32_t , const SourceInfo &); bool emitInitElemFixedPoint( uint32_t , const SourceInfo &); bool emitInitElemPtr( uint32_t , const SourceInfo &); bool emitInitElemMemberPtr( uint32_t , const SourceInfo &); bool emitInitElemFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitElem(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitElem(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitElemSint8(A0, I); case PT_Uint8: return emitInitElemUint8(A0, I); case PT_Sint16: return emitInitElemSint16(A0, I); case PT_Uint16: return emitInitElemUint16(A0, I); case PT_Sint32: return emitInitElemSint32(A0, I); case PT_Uint32: return emitInitElemUint32(A0, I); case PT_Sint64: return emitInitElemSint64(A0, I); case PT_Uint64: return emitInitElemUint64(A0, I); case PT_IntAP: return emitInitElemIntAP(A0, I); case PT_IntAPS: return emitInitElemIntAPS(A0, I); case PT_Bool: return emitInitElemBool(A0, I); case PT_FixedPoint: return emitInitElemFixedPoint(A0, I); case PT_Ptr: return emitInitElemPtr(A0, I); case PT_MemberPtr: return emitInitElemMemberPtr(A0, I); case PT_Float: return emitInitElemFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitElemSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemSint8, A0, L); } bool ByteCodeEmitter::emitInitElemUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemUint8, A0, L); } bool ByteCodeEmitter::emitInitElemSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemSint16, A0, L); } bool ByteCodeEmitter::emitInitElemUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemUint16, A0, L); } bool ByteCodeEmitter::emitInitElemSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemSint32, A0, L); } bool ByteCodeEmitter::emitInitElemUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemUint32, A0, L); } bool ByteCodeEmitter::emitInitElemSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemSint64, A0, L); } bool ByteCodeEmitter::emitInitElemUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemUint64, A0, L); } bool ByteCodeEmitter::emitInitElemIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemIntAP, A0, L); } bool ByteCodeEmitter::emitInitElemIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemIntAPS, A0, L); } bool ByteCodeEmitter::emitInitElemBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemBool, A0, L); } bool ByteCodeEmitter::emitInitElemFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemFixedPoint, A0, L); } bool ByteCodeEmitter::emitInitElemPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPtr, A0, L); } bool ByteCodeEmitter::emitInitElemMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemMemberPtr, A0, L); } bool ByteCodeEmitter::emitInitElemFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitElemSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } bool EvalEmitter::emitInitElemFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElem(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitElemPopSint8, OP_InitElemPopUint8, OP_InitElemPopSint16, OP_InitElemPopUint16, OP_InitElemPopSint32, OP_InitElemPopUint32, OP_InitElemPopSint64, OP_InitElemPopUint64, OP_InitElemPopIntAP, OP_InitElemPopIntAPS, OP_InitElemPopBool, OP_InitElemPopFixedPoint, OP_InitElemPopPtr, OP_InitElemPopMemberPtr, OP_InitElemPopFloat, #endif #ifdef GET_INTERP case OP_InitElemPopSint8: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopUint8: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopSint16: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopUint16: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopSint32: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopUint32: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopSint64: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopUint64: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopIntAP: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopIntAPS: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopBool: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopFixedPoint: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopPtr: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopMemberPtr: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } case OP_InitElemPopFloat: { const auto V0 = ReadArg(S, PC); if (!InitElemPop(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitElemPopSint8: Text.Op = PrintName("InitElemPopSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopUint8: Text.Op = PrintName("InitElemPopUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopSint16: Text.Op = PrintName("InitElemPopSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopUint16: Text.Op = PrintName("InitElemPopUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopSint32: Text.Op = PrintName("InitElemPopSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopUint32: Text.Op = PrintName("InitElemPopUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopSint64: Text.Op = PrintName("InitElemPopSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopUint64: Text.Op = PrintName("InitElemPopUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopIntAP: Text.Op = PrintName("InitElemPopIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopIntAPS: Text.Op = PrintName("InitElemPopIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopBool: Text.Op = PrintName("InitElemPopBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopFixedPoint: Text.Op = PrintName("InitElemPopFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopPtr: Text.Op = PrintName("InitElemPopPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopMemberPtr: Text.Op = PrintName("InitElemPopMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitElemPopFloat: Text.Op = PrintName("InitElemPopFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitElemPopSint8( uint32_t , const SourceInfo &); bool emitInitElemPopUint8( uint32_t , const SourceInfo &); bool emitInitElemPopSint16( uint32_t , const SourceInfo &); bool emitInitElemPopUint16( uint32_t , const SourceInfo &); bool emitInitElemPopSint32( uint32_t , const SourceInfo &); bool emitInitElemPopUint32( uint32_t , const SourceInfo &); bool emitInitElemPopSint64( uint32_t , const SourceInfo &); bool emitInitElemPopUint64( uint32_t , const SourceInfo &); bool emitInitElemPopIntAP( uint32_t , const SourceInfo &); bool emitInitElemPopIntAPS( uint32_t , const SourceInfo &); bool emitInitElemPopBool( uint32_t , const SourceInfo &); bool emitInitElemPopFixedPoint( uint32_t , const SourceInfo &); bool emitInitElemPopPtr( uint32_t , const SourceInfo &); bool emitInitElemPopMemberPtr( uint32_t , const SourceInfo &); bool emitInitElemPopFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitElemPop(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitElemPop(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitElemPopSint8(A0, I); case PT_Uint8: return emitInitElemPopUint8(A0, I); case PT_Sint16: return emitInitElemPopSint16(A0, I); case PT_Uint16: return emitInitElemPopUint16(A0, I); case PT_Sint32: return emitInitElemPopSint32(A0, I); case PT_Uint32: return emitInitElemPopUint32(A0, I); case PT_Sint64: return emitInitElemPopSint64(A0, I); case PT_Uint64: return emitInitElemPopUint64(A0, I); case PT_IntAP: return emitInitElemPopIntAP(A0, I); case PT_IntAPS: return emitInitElemPopIntAPS(A0, I); case PT_Bool: return emitInitElemPopBool(A0, I); case PT_FixedPoint: return emitInitElemPopFixedPoint(A0, I); case PT_Ptr: return emitInitElemPopPtr(A0, I); case PT_MemberPtr: return emitInitElemPopMemberPtr(A0, I); case PT_Float: return emitInitElemPopFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitElemPopSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopSint8, A0, L); } bool ByteCodeEmitter::emitInitElemPopUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopUint8, A0, L); } bool ByteCodeEmitter::emitInitElemPopSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopSint16, A0, L); } bool ByteCodeEmitter::emitInitElemPopUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopUint16, A0, L); } bool ByteCodeEmitter::emitInitElemPopSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopSint32, A0, L); } bool ByteCodeEmitter::emitInitElemPopUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopUint32, A0, L); } bool ByteCodeEmitter::emitInitElemPopSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopSint64, A0, L); } bool ByteCodeEmitter::emitInitElemPopUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopUint64, A0, L); } bool ByteCodeEmitter::emitInitElemPopIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopIntAP, A0, L); } bool ByteCodeEmitter::emitInitElemPopIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopIntAPS, A0, L); } bool ByteCodeEmitter::emitInitElemPopBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopBool, A0, L); } bool ByteCodeEmitter::emitInitElemPopFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopFixedPoint, A0, L); } bool ByteCodeEmitter::emitInitElemPopPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopPtr, A0, L); } bool ByteCodeEmitter::emitInitElemPopMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopMemberPtr, A0, L); } bool ByteCodeEmitter::emitInitElemPopFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitElemPopFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitElemPopSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } bool EvalEmitter::emitInitElemPopFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitElemPop(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitFieldSint8, OP_InitFieldUint8, OP_InitFieldSint16, OP_InitFieldUint16, OP_InitFieldSint32, OP_InitFieldUint32, OP_InitFieldSint64, OP_InitFieldUint64, OP_InitFieldIntAP, OP_InitFieldIntAPS, OP_InitFieldBool, OP_InitFieldFixedPoint, OP_InitFieldPtr, OP_InitFieldMemberPtr, OP_InitFieldFloat, #endif #ifdef GET_INTERP case OP_InitFieldSint8: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldUint8: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldSint16: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldUint16: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldSint32: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldUint32: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldSint64: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldUint64: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldIntAP: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldIntAPS: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldBool: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldFixedPoint: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldPtr: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldMemberPtr: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } case OP_InitFieldFloat: { const auto V0 = ReadArg(S, PC); if (!InitField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitFieldSint8: Text.Op = PrintName("InitFieldSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldUint8: Text.Op = PrintName("InitFieldUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldSint16: Text.Op = PrintName("InitFieldSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldUint16: Text.Op = PrintName("InitFieldUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldSint32: Text.Op = PrintName("InitFieldSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldUint32: Text.Op = PrintName("InitFieldUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldSint64: Text.Op = PrintName("InitFieldSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldUint64: Text.Op = PrintName("InitFieldUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldIntAP: Text.Op = PrintName("InitFieldIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldIntAPS: Text.Op = PrintName("InitFieldIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldBool: Text.Op = PrintName("InitFieldBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldFixedPoint: Text.Op = PrintName("InitFieldFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldPtr: Text.Op = PrintName("InitFieldPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldMemberPtr: Text.Op = PrintName("InitFieldMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldFloat: Text.Op = PrintName("InitFieldFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitFieldSint8( uint32_t , const SourceInfo &); bool emitInitFieldUint8( uint32_t , const SourceInfo &); bool emitInitFieldSint16( uint32_t , const SourceInfo &); bool emitInitFieldUint16( uint32_t , const SourceInfo &); bool emitInitFieldSint32( uint32_t , const SourceInfo &); bool emitInitFieldUint32( uint32_t , const SourceInfo &); bool emitInitFieldSint64( uint32_t , const SourceInfo &); bool emitInitFieldUint64( uint32_t , const SourceInfo &); bool emitInitFieldIntAP( uint32_t , const SourceInfo &); bool emitInitFieldIntAPS( uint32_t , const SourceInfo &); bool emitInitFieldBool( uint32_t , const SourceInfo &); bool emitInitFieldFixedPoint( uint32_t , const SourceInfo &); bool emitInitFieldPtr( uint32_t , const SourceInfo &); bool emitInitFieldMemberPtr( uint32_t , const SourceInfo &); bool emitInitFieldFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitField(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitField(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitFieldSint8(A0, I); case PT_Uint8: return emitInitFieldUint8(A0, I); case PT_Sint16: return emitInitFieldSint16(A0, I); case PT_Uint16: return emitInitFieldUint16(A0, I); case PT_Sint32: return emitInitFieldSint32(A0, I); case PT_Uint32: return emitInitFieldUint32(A0, I); case PT_Sint64: return emitInitFieldSint64(A0, I); case PT_Uint64: return emitInitFieldUint64(A0, I); case PT_IntAP: return emitInitFieldIntAP(A0, I); case PT_IntAPS: return emitInitFieldIntAPS(A0, I); case PT_Bool: return emitInitFieldBool(A0, I); case PT_FixedPoint: return emitInitFieldFixedPoint(A0, I); case PT_Ptr: return emitInitFieldPtr(A0, I); case PT_MemberPtr: return emitInitFieldMemberPtr(A0, I); case PT_Float: return emitInitFieldFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitFieldSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldSint8, A0, L); } bool ByteCodeEmitter::emitInitFieldUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldUint8, A0, L); } bool ByteCodeEmitter::emitInitFieldSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldSint16, A0, L); } bool ByteCodeEmitter::emitInitFieldUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldUint16, A0, L); } bool ByteCodeEmitter::emitInitFieldSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldSint32, A0, L); } bool ByteCodeEmitter::emitInitFieldUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldUint32, A0, L); } bool ByteCodeEmitter::emitInitFieldSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldSint64, A0, L); } bool ByteCodeEmitter::emitInitFieldUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldUint64, A0, L); } bool ByteCodeEmitter::emitInitFieldIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldIntAP, A0, L); } bool ByteCodeEmitter::emitInitFieldIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldIntAPS, A0, L); } bool ByteCodeEmitter::emitInitFieldBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldBool, A0, L); } bool ByteCodeEmitter::emitInitFieldFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldFixedPoint, A0, L); } bool ByteCodeEmitter::emitInitFieldPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldPtr, A0, L); } bool ByteCodeEmitter::emitInitFieldMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldMemberPtr, A0, L); } bool ByteCodeEmitter::emitInitFieldFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitFieldSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } bool EvalEmitter::emitInitFieldFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitFieldActivateSint8, OP_InitFieldActivateUint8, OP_InitFieldActivateSint16, OP_InitFieldActivateUint16, OP_InitFieldActivateSint32, OP_InitFieldActivateUint32, OP_InitFieldActivateSint64, OP_InitFieldActivateUint64, OP_InitFieldActivateIntAP, OP_InitFieldActivateIntAPS, OP_InitFieldActivateBool, OP_InitFieldActivateFixedPoint, OP_InitFieldActivatePtr, OP_InitFieldActivateMemberPtr, OP_InitFieldActivateFloat, #endif #ifdef GET_INTERP case OP_InitFieldActivateSint8: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateUint8: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateSint16: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateUint16: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateSint32: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateUint32: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateSint64: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateUint64: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateIntAP: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateIntAPS: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateBool: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateFixedPoint: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivatePtr: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateMemberPtr: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitFieldActivateFloat: { const auto V0 = ReadArg(S, PC); if (!InitFieldActivate(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitFieldActivateSint8: Text.Op = PrintName("InitFieldActivateSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateUint8: Text.Op = PrintName("InitFieldActivateUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateSint16: Text.Op = PrintName("InitFieldActivateSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateUint16: Text.Op = PrintName("InitFieldActivateUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateSint32: Text.Op = PrintName("InitFieldActivateSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateUint32: Text.Op = PrintName("InitFieldActivateUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateSint64: Text.Op = PrintName("InitFieldActivateSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateUint64: Text.Op = PrintName("InitFieldActivateUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateIntAP: Text.Op = PrintName("InitFieldActivateIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateIntAPS: Text.Op = PrintName("InitFieldActivateIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateBool: Text.Op = PrintName("InitFieldActivateBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateFixedPoint: Text.Op = PrintName("InitFieldActivateFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivatePtr: Text.Op = PrintName("InitFieldActivatePtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateMemberPtr: Text.Op = PrintName("InitFieldActivateMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitFieldActivateFloat: Text.Op = PrintName("InitFieldActivateFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitFieldActivateSint8( uint32_t , const SourceInfo &); bool emitInitFieldActivateUint8( uint32_t , const SourceInfo &); bool emitInitFieldActivateSint16( uint32_t , const SourceInfo &); bool emitInitFieldActivateUint16( uint32_t , const SourceInfo &); bool emitInitFieldActivateSint32( uint32_t , const SourceInfo &); bool emitInitFieldActivateUint32( uint32_t , const SourceInfo &); bool emitInitFieldActivateSint64( uint32_t , const SourceInfo &); bool emitInitFieldActivateUint64( uint32_t , const SourceInfo &); bool emitInitFieldActivateIntAP( uint32_t , const SourceInfo &); bool emitInitFieldActivateIntAPS( uint32_t , const SourceInfo &); bool emitInitFieldActivateBool( uint32_t , const SourceInfo &); bool emitInitFieldActivateFixedPoint( uint32_t , const SourceInfo &); bool emitInitFieldActivatePtr( uint32_t , const SourceInfo &); bool emitInitFieldActivateMemberPtr( uint32_t , const SourceInfo &); bool emitInitFieldActivateFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitFieldActivate(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitFieldActivate(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitFieldActivateSint8(A0, I); case PT_Uint8: return emitInitFieldActivateUint8(A0, I); case PT_Sint16: return emitInitFieldActivateSint16(A0, I); case PT_Uint16: return emitInitFieldActivateUint16(A0, I); case PT_Sint32: return emitInitFieldActivateSint32(A0, I); case PT_Uint32: return emitInitFieldActivateUint32(A0, I); case PT_Sint64: return emitInitFieldActivateSint64(A0, I); case PT_Uint64: return emitInitFieldActivateUint64(A0, I); case PT_IntAP: return emitInitFieldActivateIntAP(A0, I); case PT_IntAPS: return emitInitFieldActivateIntAPS(A0, I); case PT_Bool: return emitInitFieldActivateBool(A0, I); case PT_FixedPoint: return emitInitFieldActivateFixedPoint(A0, I); case PT_Ptr: return emitInitFieldActivatePtr(A0, I); case PT_MemberPtr: return emitInitFieldActivateMemberPtr(A0, I); case PT_Float: return emitInitFieldActivateFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitFieldActivateSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateSint8, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateUint8, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateSint16, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateUint16, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateSint32, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateUint32, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateSint64, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateUint64, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateIntAP, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateIntAPS, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateBool, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateFixedPoint, A0, L); } bool ByteCodeEmitter::emitInitFieldActivatePtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivatePtr, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateMemberPtr, A0, L); } bool ByteCodeEmitter::emitInitFieldActivateFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitFieldActivateFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitFieldActivateSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivatePtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitFieldActivateFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitFieldActivate(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitGlobalSint8, OP_InitGlobalUint8, OP_InitGlobalSint16, OP_InitGlobalUint16, OP_InitGlobalSint32, OP_InitGlobalUint32, OP_InitGlobalSint64, OP_InitGlobalUint64, OP_InitGlobalIntAP, OP_InitGlobalIntAPS, OP_InitGlobalBool, OP_InitGlobalFixedPoint, OP_InitGlobalPtr, OP_InitGlobalMemberPtr, OP_InitGlobalFloat, #endif #ifdef GET_INTERP case OP_InitGlobalSint8: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalUint8: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalSint16: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalUint16: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalSint32: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalUint32: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalSint64: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalUint64: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalIntAP: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalIntAPS: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalBool: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalFixedPoint: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalPtr: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalMemberPtr: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } case OP_InitGlobalFloat: { const auto V0 = ReadArg(S, PC); if (!InitGlobal(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitGlobalSint8: Text.Op = PrintName("InitGlobalSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalUint8: Text.Op = PrintName("InitGlobalUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalSint16: Text.Op = PrintName("InitGlobalSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalUint16: Text.Op = PrintName("InitGlobalUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalSint32: Text.Op = PrintName("InitGlobalSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalUint32: Text.Op = PrintName("InitGlobalUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalSint64: Text.Op = PrintName("InitGlobalSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalUint64: Text.Op = PrintName("InitGlobalUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalIntAP: Text.Op = PrintName("InitGlobalIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalIntAPS: Text.Op = PrintName("InitGlobalIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalBool: Text.Op = PrintName("InitGlobalBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalFixedPoint: Text.Op = PrintName("InitGlobalFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalPtr: Text.Op = PrintName("InitGlobalPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalMemberPtr: Text.Op = PrintName("InitGlobalMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalFloat: Text.Op = PrintName("InitGlobalFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitGlobalSint8( uint32_t , const SourceInfo &); bool emitInitGlobalUint8( uint32_t , const SourceInfo &); bool emitInitGlobalSint16( uint32_t , const SourceInfo &); bool emitInitGlobalUint16( uint32_t , const SourceInfo &); bool emitInitGlobalSint32( uint32_t , const SourceInfo &); bool emitInitGlobalUint32( uint32_t , const SourceInfo &); bool emitInitGlobalSint64( uint32_t , const SourceInfo &); bool emitInitGlobalUint64( uint32_t , const SourceInfo &); bool emitInitGlobalIntAP( uint32_t , const SourceInfo &); bool emitInitGlobalIntAPS( uint32_t , const SourceInfo &); bool emitInitGlobalBool( uint32_t , const SourceInfo &); bool emitInitGlobalFixedPoint( uint32_t , const SourceInfo &); bool emitInitGlobalPtr( uint32_t , const SourceInfo &); bool emitInitGlobalMemberPtr( uint32_t , const SourceInfo &); bool emitInitGlobalFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitGlobal(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitGlobal(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitGlobalSint8(A0, I); case PT_Uint8: return emitInitGlobalUint8(A0, I); case PT_Sint16: return emitInitGlobalSint16(A0, I); case PT_Uint16: return emitInitGlobalUint16(A0, I); case PT_Sint32: return emitInitGlobalSint32(A0, I); case PT_Uint32: return emitInitGlobalUint32(A0, I); case PT_Sint64: return emitInitGlobalSint64(A0, I); case PT_Uint64: return emitInitGlobalUint64(A0, I); case PT_IntAP: return emitInitGlobalIntAP(A0, I); case PT_IntAPS: return emitInitGlobalIntAPS(A0, I); case PT_Bool: return emitInitGlobalBool(A0, I); case PT_FixedPoint: return emitInitGlobalFixedPoint(A0, I); case PT_Ptr: return emitInitGlobalPtr(A0, I); case PT_MemberPtr: return emitInitGlobalMemberPtr(A0, I); case PT_Float: return emitInitGlobalFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitGlobalSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalSint8, A0, L); } bool ByteCodeEmitter::emitInitGlobalUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalUint8, A0, L); } bool ByteCodeEmitter::emitInitGlobalSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalSint16, A0, L); } bool ByteCodeEmitter::emitInitGlobalUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalUint16, A0, L); } bool ByteCodeEmitter::emitInitGlobalSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalSint32, A0, L); } bool ByteCodeEmitter::emitInitGlobalUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalUint32, A0, L); } bool ByteCodeEmitter::emitInitGlobalSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalSint64, A0, L); } bool ByteCodeEmitter::emitInitGlobalUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalUint64, A0, L); } bool ByteCodeEmitter::emitInitGlobalIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalIntAP, A0, L); } bool ByteCodeEmitter::emitInitGlobalIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalIntAPS, A0, L); } bool ByteCodeEmitter::emitInitGlobalBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalBool, A0, L); } bool ByteCodeEmitter::emitInitGlobalFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalFixedPoint, A0, L); } bool ByteCodeEmitter::emitInitGlobalPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalPtr, A0, L); } bool ByteCodeEmitter::emitInitGlobalMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalMemberPtr, A0, L); } bool ByteCodeEmitter::emitInitGlobalFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitGlobalFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitGlobalSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } bool EvalEmitter::emitInitGlobalFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobal(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitGlobalTempSint8, OP_InitGlobalTempUint8, OP_InitGlobalTempSint16, OP_InitGlobalTempUint16, OP_InitGlobalTempSint32, OP_InitGlobalTempUint32, OP_InitGlobalTempSint64, OP_InitGlobalTempUint64, OP_InitGlobalTempIntAP, OP_InitGlobalTempIntAPS, OP_InitGlobalTempBool, OP_InitGlobalTempFixedPoint, OP_InitGlobalTempPtr, OP_InitGlobalTempMemberPtr, OP_InitGlobalTempFloat, #endif #ifdef GET_INTERP case OP_InitGlobalTempSint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempUint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempSint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempUint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempSint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempUint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempSint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempUint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempIntAP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempIntAPS: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempBool: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempFixedPoint: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempPtr: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempMemberPtr: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } case OP_InitGlobalTempFloat: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitGlobalTemp(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitGlobalTempSint8: Text.Op = PrintName("InitGlobalTempSint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempUint8: Text.Op = PrintName("InitGlobalTempUint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempSint16: Text.Op = PrintName("InitGlobalTempSint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempUint16: Text.Op = PrintName("InitGlobalTempUint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempSint32: Text.Op = PrintName("InitGlobalTempSint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempUint32: Text.Op = PrintName("InitGlobalTempUint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempSint64: Text.Op = PrintName("InitGlobalTempSint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempUint64: Text.Op = PrintName("InitGlobalTempUint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempIntAP: Text.Op = PrintName("InitGlobalTempIntAP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempIntAPS: Text.Op = PrintName("InitGlobalTempIntAPS"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempBool: Text.Op = PrintName("InitGlobalTempBool"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempFixedPoint: Text.Op = PrintName("InitGlobalTempFixedPoint"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempPtr: Text.Op = PrintName("InitGlobalTempPtr"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempMemberPtr: Text.Op = PrintName("InitGlobalTempMemberPtr"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitGlobalTempFloat: Text.Op = PrintName("InitGlobalTempFloat"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitGlobalTempSint8( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempUint8( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempSint16( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempUint16( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempSint32( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempUint32( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempSint64( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempUint64( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempIntAP( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempIntAPS( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempBool( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempFixedPoint( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempPtr( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempMemberPtr( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); bool emitInitGlobalTempFloat( uint32_t , const LifetimeExtendedTemporaryDecl * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitGlobalTemp(PrimType, uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitGlobalTemp(PrimType T0, uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitGlobalTempSint8(A0, A1, I); case PT_Uint8: return emitInitGlobalTempUint8(A0, A1, I); case PT_Sint16: return emitInitGlobalTempSint16(A0, A1, I); case PT_Uint16: return emitInitGlobalTempUint16(A0, A1, I); case PT_Sint32: return emitInitGlobalTempSint32(A0, A1, I); case PT_Uint32: return emitInitGlobalTempUint32(A0, A1, I); case PT_Sint64: return emitInitGlobalTempSint64(A0, A1, I); case PT_Uint64: return emitInitGlobalTempUint64(A0, A1, I); case PT_IntAP: return emitInitGlobalTempIntAP(A0, A1, I); case PT_IntAPS: return emitInitGlobalTempIntAPS(A0, A1, I); case PT_Bool: return emitInitGlobalTempBool(A0, A1, I); case PT_FixedPoint: return emitInitGlobalTempFixedPoint(A0, A1, I); case PT_Ptr: return emitInitGlobalTempPtr(A0, A1, I); case PT_MemberPtr: return emitInitGlobalTempMemberPtr(A0, A1, I); case PT_Float: return emitInitGlobalTempFloat(A0, A1, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitGlobalTempSint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempSint8, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempUint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempUint8, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempSint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempSint16, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempUint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempUint16, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempSint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempSint32, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempUint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempUint32, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempSint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempSint64, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempUint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempUint64, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempIntAP( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempIntAP, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempIntAPS( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempIntAPS, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempBool( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempBool, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempFixedPoint( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempFixedPoint, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempPtr, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempMemberPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempMemberPtr, A0, A1, L); } bool ByteCodeEmitter::emitInitGlobalTempFloat( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { return emitOp(OP_InitGlobalTempFloat, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitGlobalTempSint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempUint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempSint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempUint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempSint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempUint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempSint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempUint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempIntAP( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempIntAPS( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempBool( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempFixedPoint( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempMemberPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } bool EvalEmitter::emitInitGlobalTempFloat( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTemp(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_InitGlobalTempComp, #endif #ifdef GET_INTERP case OP_InitGlobalTempComp: { const auto V0 = ReadArg(S, PC); if (!InitGlobalTempComp(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitGlobalTempComp: Text.Op = PrintName("InitGlobalTempComp"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitGlobalTempComp( const LifetimeExtendedTemporaryDecl * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitGlobalTempComp( const LifetimeExtendedTemporaryDecl * A0, const SourceInfo &L) { return emitOp(OP_InitGlobalTempComp, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitGlobalTempComp( const LifetimeExtendedTemporaryDecl * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitGlobalTempComp(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitPopSint8, OP_InitPopUint8, OP_InitPopSint16, OP_InitPopUint16, OP_InitPopSint32, OP_InitPopUint32, OP_InitPopSint64, OP_InitPopUint64, OP_InitPopIntAP, OP_InitPopIntAPS, OP_InitPopBool, OP_InitPopFixedPoint, OP_InitPopPtr, OP_InitPopMemberPtr, OP_InitPopFloat, #endif #ifdef GET_INTERP case OP_InitPopSint8: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopUint8: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopSint16: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopUint16: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopSint32: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopUint32: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopSint64: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopUint64: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopIntAP: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopIntAPS: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopBool: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopFixedPoint: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopPtr: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopMemberPtr: { if (!InitPop(S, OpPC)) return false; continue; } case OP_InitPopFloat: { if (!InitPop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitPopSint8: Text.Op = PrintName("InitPopSint8"); break; case OP_InitPopUint8: Text.Op = PrintName("InitPopUint8"); break; case OP_InitPopSint16: Text.Op = PrintName("InitPopSint16"); break; case OP_InitPopUint16: Text.Op = PrintName("InitPopUint16"); break; case OP_InitPopSint32: Text.Op = PrintName("InitPopSint32"); break; case OP_InitPopUint32: Text.Op = PrintName("InitPopUint32"); break; case OP_InitPopSint64: Text.Op = PrintName("InitPopSint64"); break; case OP_InitPopUint64: Text.Op = PrintName("InitPopUint64"); break; case OP_InitPopIntAP: Text.Op = PrintName("InitPopIntAP"); break; case OP_InitPopIntAPS: Text.Op = PrintName("InitPopIntAPS"); break; case OP_InitPopBool: Text.Op = PrintName("InitPopBool"); break; case OP_InitPopFixedPoint: Text.Op = PrintName("InitPopFixedPoint"); break; case OP_InitPopPtr: Text.Op = PrintName("InitPopPtr"); break; case OP_InitPopMemberPtr: Text.Op = PrintName("InitPopMemberPtr"); break; case OP_InitPopFloat: Text.Op = PrintName("InitPopFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitPopSint8(const SourceInfo &); bool emitInitPopUint8(const SourceInfo &); bool emitInitPopSint16(const SourceInfo &); bool emitInitPopUint16(const SourceInfo &); bool emitInitPopSint32(const SourceInfo &); bool emitInitPopUint32(const SourceInfo &); bool emitInitPopSint64(const SourceInfo &); bool emitInitPopUint64(const SourceInfo &); bool emitInitPopIntAP(const SourceInfo &); bool emitInitPopIntAPS(const SourceInfo &); bool emitInitPopBool(const SourceInfo &); bool emitInitPopFixedPoint(const SourceInfo &); bool emitInitPopPtr(const SourceInfo &); bool emitInitPopMemberPtr(const SourceInfo &); bool emitInitPopFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitPop(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitPop(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitPopSint8(I); case PT_Uint8: return emitInitPopUint8(I); case PT_Sint16: return emitInitPopSint16(I); case PT_Uint16: return emitInitPopUint16(I); case PT_Sint32: return emitInitPopSint32(I); case PT_Uint32: return emitInitPopUint32(I); case PT_Sint64: return emitInitPopSint64(I); case PT_Uint64: return emitInitPopUint64(I); case PT_IntAP: return emitInitPopIntAP(I); case PT_IntAPS: return emitInitPopIntAPS(I); case PT_Bool: return emitInitPopBool(I); case PT_FixedPoint: return emitInitPopFixedPoint(I); case PT_Ptr: return emitInitPopPtr(I); case PT_MemberPtr: return emitInitPopMemberPtr(I); case PT_Float: return emitInitPopFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitPopSint8(const SourceInfo &L) { return emitOp<>(OP_InitPopSint8, L); } bool ByteCodeEmitter::emitInitPopUint8(const SourceInfo &L) { return emitOp<>(OP_InitPopUint8, L); } bool ByteCodeEmitter::emitInitPopSint16(const SourceInfo &L) { return emitOp<>(OP_InitPopSint16, L); } bool ByteCodeEmitter::emitInitPopUint16(const SourceInfo &L) { return emitOp<>(OP_InitPopUint16, L); } bool ByteCodeEmitter::emitInitPopSint32(const SourceInfo &L) { return emitOp<>(OP_InitPopSint32, L); } bool ByteCodeEmitter::emitInitPopUint32(const SourceInfo &L) { return emitOp<>(OP_InitPopUint32, L); } bool ByteCodeEmitter::emitInitPopSint64(const SourceInfo &L) { return emitOp<>(OP_InitPopSint64, L); } bool ByteCodeEmitter::emitInitPopUint64(const SourceInfo &L) { return emitOp<>(OP_InitPopUint64, L); } bool ByteCodeEmitter::emitInitPopIntAP(const SourceInfo &L) { return emitOp<>(OP_InitPopIntAP, L); } bool ByteCodeEmitter::emitInitPopIntAPS(const SourceInfo &L) { return emitOp<>(OP_InitPopIntAPS, L); } bool ByteCodeEmitter::emitInitPopBool(const SourceInfo &L) { return emitOp<>(OP_InitPopBool, L); } bool ByteCodeEmitter::emitInitPopFixedPoint(const SourceInfo &L) { return emitOp<>(OP_InitPopFixedPoint, L); } bool ByteCodeEmitter::emitInitPopPtr(const SourceInfo &L) { return emitOp<>(OP_InitPopPtr, L); } bool ByteCodeEmitter::emitInitPopMemberPtr(const SourceInfo &L) { return emitOp<>(OP_InitPopMemberPtr, L); } bool ByteCodeEmitter::emitInitPopFloat(const SourceInfo &L) { return emitOp<>(OP_InitPopFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitPopSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } bool EvalEmitter::emitInitPopFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitPop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_InitScope, #endif #ifdef GET_INTERP case OP_InitScope: { const auto V0 = ReadArg(S, PC); if (!InitScope(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitScope: Text.Op = PrintName("InitScope"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitScope( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitScope( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitScope, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitScope( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitScope(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitThisBitFieldSint8, OP_InitThisBitFieldUint8, OP_InitThisBitFieldSint16, OP_InitThisBitFieldUint16, OP_InitThisBitFieldSint32, OP_InitThisBitFieldUint32, OP_InitThisBitFieldSint64, OP_InitThisBitFieldUint64, OP_InitThisBitFieldIntAP, OP_InitThisBitFieldIntAPS, OP_InitThisBitFieldBool, OP_InitThisBitFieldFixedPoint, #endif #ifdef GET_INTERP case OP_InitThisBitFieldSint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldUint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldSint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldUint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldSint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldUint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldSint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldUint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldIntAP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldIntAPS: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldBool: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldFixedPoint: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitField(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitThisBitFieldSint8: Text.Op = PrintName("InitThisBitFieldSint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldUint8: Text.Op = PrintName("InitThisBitFieldUint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldSint16: Text.Op = PrintName("InitThisBitFieldSint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldUint16: Text.Op = PrintName("InitThisBitFieldUint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldSint32: Text.Op = PrintName("InitThisBitFieldSint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldUint32: Text.Op = PrintName("InitThisBitFieldUint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldSint64: Text.Op = PrintName("InitThisBitFieldSint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldUint64: Text.Op = PrintName("InitThisBitFieldUint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldIntAP: Text.Op = PrintName("InitThisBitFieldIntAP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldIntAPS: Text.Op = PrintName("InitThisBitFieldIntAPS"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldBool: Text.Op = PrintName("InitThisBitFieldBool"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldFixedPoint: Text.Op = PrintName("InitThisBitFieldFixedPoint"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitThisBitFieldSint8( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldUint8( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldSint16( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldUint16( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldSint32( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldUint32( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldSint64( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldUint64( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldIntAP( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldIntAPS( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldBool( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldFixedPoint( const Record::Field * , uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitThisBitField(PrimType, const Record::Field *, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitThisBitField(PrimType T0, const Record::Field * A0, uint32_t A1, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitThisBitFieldSint8(A0, A1, I); case PT_Uint8: return emitInitThisBitFieldUint8(A0, A1, I); case PT_Sint16: return emitInitThisBitFieldSint16(A0, A1, I); case PT_Uint16: return emitInitThisBitFieldUint16(A0, A1, I); case PT_Sint32: return emitInitThisBitFieldSint32(A0, A1, I); case PT_Uint32: return emitInitThisBitFieldUint32(A0, A1, I); case PT_Sint64: return emitInitThisBitFieldSint64(A0, A1, I); case PT_Uint64: return emitInitThisBitFieldUint64(A0, A1, I); case PT_IntAP: return emitInitThisBitFieldIntAP(A0, A1, I); case PT_IntAPS: return emitInitThisBitFieldIntAPS(A0, A1, I); case PT_Bool: return emitInitThisBitFieldBool(A0, A1, I); case PT_FixedPoint: return emitInitThisBitFieldFixedPoint(A0, A1, I); default: llvm_unreachable("invalid type: emitInitThisBitField"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitThisBitFieldSint8( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldSint8, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldUint8( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldUint8, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldSint16( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldSint16, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldUint16( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldUint16, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldSint32( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldSint32, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldUint32( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldUint32, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldSint64( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldSint64, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldUint64( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldUint64, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldIntAP( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldIntAP, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldIntAPS( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldIntAPS, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldBool( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldBool, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldFixedPoint( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldFixedPoint, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitThisBitFieldSint8( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldUint8( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldSint16( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldUint16( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldSint32( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldUint32( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldSint64( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldUint64( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldIntAP( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldIntAPS( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldBool( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldFixedPoint( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitField(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_InitThisBitFieldActivateSint8, OP_InitThisBitFieldActivateUint8, OP_InitThisBitFieldActivateSint16, OP_InitThisBitFieldActivateUint16, OP_InitThisBitFieldActivateSint32, OP_InitThisBitFieldActivateUint32, OP_InitThisBitFieldActivateSint64, OP_InitThisBitFieldActivateUint64, OP_InitThisBitFieldActivateIntAP, OP_InitThisBitFieldActivateIntAPS, OP_InitThisBitFieldActivateBool, OP_InitThisBitFieldActivateFixedPoint, #endif #ifdef GET_INTERP case OP_InitThisBitFieldActivateSint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateUint8: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateSint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateUint16: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateSint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateUint32: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateSint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateUint64: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateIntAP: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateIntAPS: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateBool: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } case OP_InitThisBitFieldActivateFixedPoint: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InitThisBitFieldActivate(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitThisBitFieldActivateSint8: Text.Op = PrintName("InitThisBitFieldActivateSint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateUint8: Text.Op = PrintName("InitThisBitFieldActivateUint8"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateSint16: Text.Op = PrintName("InitThisBitFieldActivateSint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateUint16: Text.Op = PrintName("InitThisBitFieldActivateUint16"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateSint32: Text.Op = PrintName("InitThisBitFieldActivateSint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateUint32: Text.Op = PrintName("InitThisBitFieldActivateUint32"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateSint64: Text.Op = PrintName("InitThisBitFieldActivateSint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateUint64: Text.Op = PrintName("InitThisBitFieldActivateUint64"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateIntAP: Text.Op = PrintName("InitThisBitFieldActivateIntAP"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateIntAPS: Text.Op = PrintName("InitThisBitFieldActivateIntAPS"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateBool: Text.Op = PrintName("InitThisBitFieldActivateBool"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisBitFieldActivateFixedPoint: Text.Op = PrintName("InitThisBitFieldActivateFixedPoint"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitThisBitFieldActivateSint8( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateUint8( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateSint16( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateUint16( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateSint32( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateUint32( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateSint64( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateUint64( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateIntAP( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateIntAPS( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateBool( const Record::Field * , uint32_t , const SourceInfo &); bool emitInitThisBitFieldActivateFixedPoint( const Record::Field * , uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitThisBitFieldActivate(PrimType, const Record::Field *, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitThisBitFieldActivate(PrimType T0, const Record::Field * A0, uint32_t A1, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitThisBitFieldActivateSint8(A0, A1, I); case PT_Uint8: return emitInitThisBitFieldActivateUint8(A0, A1, I); case PT_Sint16: return emitInitThisBitFieldActivateSint16(A0, A1, I); case PT_Uint16: return emitInitThisBitFieldActivateUint16(A0, A1, I); case PT_Sint32: return emitInitThisBitFieldActivateSint32(A0, A1, I); case PT_Uint32: return emitInitThisBitFieldActivateUint32(A0, A1, I); case PT_Sint64: return emitInitThisBitFieldActivateSint64(A0, A1, I); case PT_Uint64: return emitInitThisBitFieldActivateUint64(A0, A1, I); case PT_IntAP: return emitInitThisBitFieldActivateIntAP(A0, A1, I); case PT_IntAPS: return emitInitThisBitFieldActivateIntAPS(A0, A1, I); case PT_Bool: return emitInitThisBitFieldActivateBool(A0, A1, I); case PT_FixedPoint: return emitInitThisBitFieldActivateFixedPoint(A0, A1, I); default: llvm_unreachable("invalid type: emitInitThisBitFieldActivate"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitThisBitFieldActivateSint8( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateSint8, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateUint8( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateUint8, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateSint16( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateSint16, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateUint16( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateUint16, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateSint32( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateSint32, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateUint32( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateUint32, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateSint64( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateSint64, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateUint64( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateUint64, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateIntAP( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateIntAP, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateIntAPS( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateIntAPS, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateBool( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateBool, A0, A1, L); } bool ByteCodeEmitter::emitInitThisBitFieldActivateFixedPoint( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { return emitOp(OP_InitThisBitFieldActivateFixedPoint, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitThisBitFieldActivateSint8( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateUint8( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateSint16( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateUint16( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateSint32( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateUint32( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateSint64( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateUint64( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateIntAP( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateIntAPS( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateBool( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } bool EvalEmitter::emitInitThisBitFieldActivateFixedPoint( const Record::Field * A0, uint32_t A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisBitFieldActivate(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_InitThisFieldSint8, OP_InitThisFieldUint8, OP_InitThisFieldSint16, OP_InitThisFieldUint16, OP_InitThisFieldSint32, OP_InitThisFieldUint32, OP_InitThisFieldSint64, OP_InitThisFieldUint64, OP_InitThisFieldIntAP, OP_InitThisFieldIntAPS, OP_InitThisFieldBool, OP_InitThisFieldFixedPoint, OP_InitThisFieldPtr, OP_InitThisFieldMemberPtr, OP_InitThisFieldFloat, #endif #ifdef GET_INTERP case OP_InitThisFieldSint8: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldUint8: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldSint16: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldUint16: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldSint32: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldUint32: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldSint64: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldUint64: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldIntAP: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldIntAPS: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldBool: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldFixedPoint: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldPtr: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldMemberPtr: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldFloat: { const auto V0 = ReadArg(S, PC); if (!InitThisField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitThisFieldSint8: Text.Op = PrintName("InitThisFieldSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldUint8: Text.Op = PrintName("InitThisFieldUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldSint16: Text.Op = PrintName("InitThisFieldSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldUint16: Text.Op = PrintName("InitThisFieldUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldSint32: Text.Op = PrintName("InitThisFieldSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldUint32: Text.Op = PrintName("InitThisFieldUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldSint64: Text.Op = PrintName("InitThisFieldSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldUint64: Text.Op = PrintName("InitThisFieldUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldIntAP: Text.Op = PrintName("InitThisFieldIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldIntAPS: Text.Op = PrintName("InitThisFieldIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldBool: Text.Op = PrintName("InitThisFieldBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldFixedPoint: Text.Op = PrintName("InitThisFieldFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldPtr: Text.Op = PrintName("InitThisFieldPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldMemberPtr: Text.Op = PrintName("InitThisFieldMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldFloat: Text.Op = PrintName("InitThisFieldFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitThisFieldSint8( uint32_t , const SourceInfo &); bool emitInitThisFieldUint8( uint32_t , const SourceInfo &); bool emitInitThisFieldSint16( uint32_t , const SourceInfo &); bool emitInitThisFieldUint16( uint32_t , const SourceInfo &); bool emitInitThisFieldSint32( uint32_t , const SourceInfo &); bool emitInitThisFieldUint32( uint32_t , const SourceInfo &); bool emitInitThisFieldSint64( uint32_t , const SourceInfo &); bool emitInitThisFieldUint64( uint32_t , const SourceInfo &); bool emitInitThisFieldIntAP( uint32_t , const SourceInfo &); bool emitInitThisFieldIntAPS( uint32_t , const SourceInfo &); bool emitInitThisFieldBool( uint32_t , const SourceInfo &); bool emitInitThisFieldFixedPoint( uint32_t , const SourceInfo &); bool emitInitThisFieldPtr( uint32_t , const SourceInfo &); bool emitInitThisFieldMemberPtr( uint32_t , const SourceInfo &); bool emitInitThisFieldFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitThisField(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitThisField(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitThisFieldSint8(A0, I); case PT_Uint8: return emitInitThisFieldUint8(A0, I); case PT_Sint16: return emitInitThisFieldSint16(A0, I); case PT_Uint16: return emitInitThisFieldUint16(A0, I); case PT_Sint32: return emitInitThisFieldSint32(A0, I); case PT_Uint32: return emitInitThisFieldUint32(A0, I); case PT_Sint64: return emitInitThisFieldSint64(A0, I); case PT_Uint64: return emitInitThisFieldUint64(A0, I); case PT_IntAP: return emitInitThisFieldIntAP(A0, I); case PT_IntAPS: return emitInitThisFieldIntAPS(A0, I); case PT_Bool: return emitInitThisFieldBool(A0, I); case PT_FixedPoint: return emitInitThisFieldFixedPoint(A0, I); case PT_Ptr: return emitInitThisFieldPtr(A0, I); case PT_MemberPtr: return emitInitThisFieldMemberPtr(A0, I); case PT_Float: return emitInitThisFieldFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitThisFieldSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldSint8, A0, L); } bool ByteCodeEmitter::emitInitThisFieldUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldUint8, A0, L); } bool ByteCodeEmitter::emitInitThisFieldSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldSint16, A0, L); } bool ByteCodeEmitter::emitInitThisFieldUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldUint16, A0, L); } bool ByteCodeEmitter::emitInitThisFieldSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldSint32, A0, L); } bool ByteCodeEmitter::emitInitThisFieldUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldUint32, A0, L); } bool ByteCodeEmitter::emitInitThisFieldSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldSint64, A0, L); } bool ByteCodeEmitter::emitInitThisFieldUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldUint64, A0, L); } bool ByteCodeEmitter::emitInitThisFieldIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldIntAP, A0, L); } bool ByteCodeEmitter::emitInitThisFieldIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldIntAPS, A0, L); } bool ByteCodeEmitter::emitInitThisFieldBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldBool, A0, L); } bool ByteCodeEmitter::emitInitThisFieldFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldFixedPoint, A0, L); } bool ByteCodeEmitter::emitInitThisFieldPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldPtr, A0, L); } bool ByteCodeEmitter::emitInitThisFieldMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldMemberPtr, A0, L); } bool ByteCodeEmitter::emitInitThisFieldFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitThisFieldSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InitThisFieldActivateSint8, OP_InitThisFieldActivateUint8, OP_InitThisFieldActivateSint16, OP_InitThisFieldActivateUint16, OP_InitThisFieldActivateSint32, OP_InitThisFieldActivateUint32, OP_InitThisFieldActivateSint64, OP_InitThisFieldActivateUint64, OP_InitThisFieldActivateIntAP, OP_InitThisFieldActivateIntAPS, OP_InitThisFieldActivateBool, OP_InitThisFieldActivateFixedPoint, OP_InitThisFieldActivatePtr, OP_InitThisFieldActivateMemberPtr, OP_InitThisFieldActivateFloat, #endif #ifdef GET_INTERP case OP_InitThisFieldActivateSint8: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateUint8: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateSint16: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateUint16: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateSint32: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateUint32: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateSint64: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateUint64: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateIntAP: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateIntAPS: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateBool: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateFixedPoint: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivatePtr: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateMemberPtr: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } case OP_InitThisFieldActivateFloat: { const auto V0 = ReadArg(S, PC); if (!InitThisFieldActivate(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InitThisFieldActivateSint8: Text.Op = PrintName("InitThisFieldActivateSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateUint8: Text.Op = PrintName("InitThisFieldActivateUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateSint16: Text.Op = PrintName("InitThisFieldActivateSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateUint16: Text.Op = PrintName("InitThisFieldActivateUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateSint32: Text.Op = PrintName("InitThisFieldActivateSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateUint32: Text.Op = PrintName("InitThisFieldActivateUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateSint64: Text.Op = PrintName("InitThisFieldActivateSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateUint64: Text.Op = PrintName("InitThisFieldActivateUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateIntAP: Text.Op = PrintName("InitThisFieldActivateIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateIntAPS: Text.Op = PrintName("InitThisFieldActivateIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateBool: Text.Op = PrintName("InitThisFieldActivateBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateFixedPoint: Text.Op = PrintName("InitThisFieldActivateFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivatePtr: Text.Op = PrintName("InitThisFieldActivatePtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateMemberPtr: Text.Op = PrintName("InitThisFieldActivateMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_InitThisFieldActivateFloat: Text.Op = PrintName("InitThisFieldActivateFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInitThisFieldActivateSint8( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateUint8( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateSint16( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateUint16( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateSint32( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateUint32( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateSint64( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateUint64( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateIntAP( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateIntAPS( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateBool( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateFixedPoint( uint32_t , const SourceInfo &); bool emitInitThisFieldActivatePtr( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateMemberPtr( uint32_t , const SourceInfo &); bool emitInitThisFieldActivateFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitInitThisFieldActivate(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitInitThisFieldActivate(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitInitThisFieldActivateSint8(A0, I); case PT_Uint8: return emitInitThisFieldActivateUint8(A0, I); case PT_Sint16: return emitInitThisFieldActivateSint16(A0, I); case PT_Uint16: return emitInitThisFieldActivateUint16(A0, I); case PT_Sint32: return emitInitThisFieldActivateSint32(A0, I); case PT_Uint32: return emitInitThisFieldActivateUint32(A0, I); case PT_Sint64: return emitInitThisFieldActivateSint64(A0, I); case PT_Uint64: return emitInitThisFieldActivateUint64(A0, I); case PT_IntAP: return emitInitThisFieldActivateIntAP(A0, I); case PT_IntAPS: return emitInitThisFieldActivateIntAPS(A0, I); case PT_Bool: return emitInitThisFieldActivateBool(A0, I); case PT_FixedPoint: return emitInitThisFieldActivateFixedPoint(A0, I); case PT_Ptr: return emitInitThisFieldActivatePtr(A0, I); case PT_MemberPtr: return emitInitThisFieldActivateMemberPtr(A0, I); case PT_Float: return emitInitThisFieldActivateFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInitThisFieldActivateSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateSint8, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateUint8, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateSint16, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateUint16, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateSint32, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateUint32, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateSint64, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateUint64, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateIntAP, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateIntAPS, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateBool, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateFixedPoint, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivatePtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivatePtr, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateMemberPtr, A0, L); } bool ByteCodeEmitter::emitInitThisFieldActivateFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InitThisFieldActivateFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInitThisFieldActivateSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivatePtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } bool EvalEmitter::emitInitThisFieldActivateFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InitThisFieldActivate(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_Inv, #endif #ifdef GET_INTERP case OP_Inv: { if (!Inv(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_Inv: Text.Op = PrintName("Inv"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInv(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInv(const SourceInfo &L) { return emitOp<>(OP_Inv, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInv(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Inv(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Invalid, #endif #ifdef GET_INTERP case OP_Invalid: { if (!Invalid(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_Invalid: Text.Op = PrintName("Invalid"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInvalid(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInvalid(const SourceInfo &L) { return emitOp<>(OP_Invalid, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInvalid(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Invalid(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_InvalidCast, #endif #ifdef GET_INTERP case OP_InvalidCast: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InvalidCast(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_InvalidCast: Text.Op = PrintName("InvalidCast"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInvalidCast( interp::CastKind , bool , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInvalidCast( interp::CastKind A0, bool A1, const SourceInfo &L) { return emitOp(OP_InvalidCast, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInvalidCast( interp::CastKind A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InvalidCast(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_InvalidDeclRef, #endif #ifdef GET_INTERP case OP_InvalidDeclRef: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!InvalidDeclRef(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_InvalidDeclRef: Text.Op = PrintName("InvalidDeclRef"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInvalidDeclRef( const DeclRefExpr * , bool , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInvalidDeclRef( const DeclRefExpr * A0, bool A1, const SourceInfo &L) { return emitOp(OP_InvalidDeclRef, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInvalidDeclRef( const DeclRefExpr * A0, bool A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InvalidDeclRef(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_InvalidNewDeleteExpr, #endif #ifdef GET_INTERP case OP_InvalidNewDeleteExpr: { const auto V0 = ReadArg(S, PC); if (!InvalidNewDeleteExpr(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InvalidNewDeleteExpr: Text.Op = PrintName("InvalidNewDeleteExpr"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInvalidNewDeleteExpr( const Expr * , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInvalidNewDeleteExpr( const Expr * A0, const SourceInfo &L) { return emitOp(OP_InvalidNewDeleteExpr, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInvalidNewDeleteExpr( const Expr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InvalidNewDeleteExpr(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_InvalidShuffleVectorIndex, #endif #ifdef GET_INTERP case OP_InvalidShuffleVectorIndex: { const auto V0 = ReadArg(S, PC); if (!InvalidShuffleVectorIndex(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_InvalidShuffleVectorIndex: Text.Op = PrintName("InvalidShuffleVectorIndex"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitInvalidShuffleVectorIndex( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitInvalidShuffleVectorIndex( uint32_t A0, const SourceInfo &L) { return emitOp(OP_InvalidShuffleVectorIndex, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitInvalidShuffleVectorIndex( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return InvalidShuffleVectorIndex(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_IsConstantContext, #endif #ifdef GET_INTERP case OP_IsConstantContext: { if (!IsConstantContext(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_IsConstantContext: Text.Op = PrintName("IsConstantContext"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitIsConstantContext(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitIsConstantContext(const SourceInfo &L) { return emitOp<>(OP_IsConstantContext, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitIsConstantContext(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IsConstantContext(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_IsNonNullPtr, OP_IsNonNullMemberPtr, #endif #ifdef GET_INTERP case OP_IsNonNullPtr: { if (!IsNonNull(S, OpPC)) return false; continue; } case OP_IsNonNullMemberPtr: { if (!IsNonNull(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_IsNonNullPtr: Text.Op = PrintName("IsNonNullPtr"); break; case OP_IsNonNullMemberPtr: Text.Op = PrintName("IsNonNullMemberPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitIsNonNullPtr(const SourceInfo &); bool emitIsNonNullMemberPtr(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitIsNonNull(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitIsNonNull(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Ptr: return emitIsNonNullPtr(I); case PT_MemberPtr: return emitIsNonNullMemberPtr(I); default: llvm_unreachable("invalid type: emitIsNonNull"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitIsNonNullPtr(const SourceInfo &L) { return emitOp<>(OP_IsNonNullPtr, L); } bool ByteCodeEmitter::emitIsNonNullMemberPtr(const SourceInfo &L) { return emitOp<>(OP_IsNonNullMemberPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitIsNonNullPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IsNonNull(S, OpPC); } bool EvalEmitter::emitIsNonNullMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return IsNonNull(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Jf, #endif #ifdef GET_INTERP case OP_Jf: { const auto V0 = ReadArg(S, PC); if (!Jf(S, PC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Jf: Text.Op = PrintName("Jf"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitJf( int32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitJf( int32_t A0, const SourceInfo &L) { return emitOp(OP_Jf, A0, L); } #endif #ifdef GET_OPCODE_NAMES OP_Jmp, #endif #ifdef GET_INTERP case OP_Jmp: { const auto V0 = ReadArg(S, PC); if (!Jmp(S, PC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Jmp: Text.Op = PrintName("Jmp"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitJmp( int32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitJmp( int32_t A0, const SourceInfo &L) { return emitOp(OP_Jmp, A0, L); } #endif #ifdef GET_OPCODE_NAMES OP_Jt, #endif #ifdef GET_INTERP case OP_Jt: { const auto V0 = ReadArg(S, PC); if (!Jt(S, PC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Jt: Text.Op = PrintName("Jt"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitJt( int32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitJt( int32_t A0, const SourceInfo &L) { return emitOp(OP_Jt, A0, L); } #endif #ifdef GET_OPCODE_NAMES OP_LESint8, OP_LEUint8, OP_LESint16, OP_LEUint16, OP_LESint32, OP_LEUint32, OP_LESint64, OP_LEUint64, OP_LEIntAP, OP_LEIntAPS, OP_LEBool, OP_LEFixedPoint, OP_LEPtr, OP_LEFloat, #endif #ifdef GET_INTERP case OP_LESint8: { if (!LE(S, OpPC)) return false; continue; } case OP_LEUint8: { if (!LE(S, OpPC)) return false; continue; } case OP_LESint16: { if (!LE(S, OpPC)) return false; continue; } case OP_LEUint16: { if (!LE(S, OpPC)) return false; continue; } case OP_LESint32: { if (!LE(S, OpPC)) return false; continue; } case OP_LEUint32: { if (!LE(S, OpPC)) return false; continue; } case OP_LESint64: { if (!LE(S, OpPC)) return false; continue; } case OP_LEUint64: { if (!LE(S, OpPC)) return false; continue; } case OP_LEIntAP: { if (!LE(S, OpPC)) return false; continue; } case OP_LEIntAPS: { if (!LE(S, OpPC)) return false; continue; } case OP_LEBool: { if (!LE(S, OpPC)) return false; continue; } case OP_LEFixedPoint: { if (!LE(S, OpPC)) return false; continue; } case OP_LEPtr: { if (!LE(S, OpPC)) return false; continue; } case OP_LEFloat: { if (!LE(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_LESint8: Text.Op = PrintName("LESint8"); break; case OP_LEUint8: Text.Op = PrintName("LEUint8"); break; case OP_LESint16: Text.Op = PrintName("LESint16"); break; case OP_LEUint16: Text.Op = PrintName("LEUint16"); break; case OP_LESint32: Text.Op = PrintName("LESint32"); break; case OP_LEUint32: Text.Op = PrintName("LEUint32"); break; case OP_LESint64: Text.Op = PrintName("LESint64"); break; case OP_LEUint64: Text.Op = PrintName("LEUint64"); break; case OP_LEIntAP: Text.Op = PrintName("LEIntAP"); break; case OP_LEIntAPS: Text.Op = PrintName("LEIntAPS"); break; case OP_LEBool: Text.Op = PrintName("LEBool"); break; case OP_LEFixedPoint: Text.Op = PrintName("LEFixedPoint"); break; case OP_LEPtr: Text.Op = PrintName("LEPtr"); break; case OP_LEFloat: Text.Op = PrintName("LEFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitLESint8(const SourceInfo &); bool emitLEUint8(const SourceInfo &); bool emitLESint16(const SourceInfo &); bool emitLEUint16(const SourceInfo &); bool emitLESint32(const SourceInfo &); bool emitLEUint32(const SourceInfo &); bool emitLESint64(const SourceInfo &); bool emitLEUint64(const SourceInfo &); bool emitLEIntAP(const SourceInfo &); bool emitLEIntAPS(const SourceInfo &); bool emitLEBool(const SourceInfo &); bool emitLEFixedPoint(const SourceInfo &); bool emitLEPtr(const SourceInfo &); bool emitLEFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitLE(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitLE(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitLESint8(I); case PT_Uint8: return emitLEUint8(I); case PT_Sint16: return emitLESint16(I); case PT_Uint16: return emitLEUint16(I); case PT_Sint32: return emitLESint32(I); case PT_Uint32: return emitLEUint32(I); case PT_Sint64: return emitLESint64(I); case PT_Uint64: return emitLEUint64(I); case PT_IntAP: return emitLEIntAP(I); case PT_IntAPS: return emitLEIntAPS(I); case PT_Bool: return emitLEBool(I); case PT_FixedPoint: return emitLEFixedPoint(I); case PT_Ptr: return emitLEPtr(I); case PT_Float: return emitLEFloat(I); default: llvm_unreachable("invalid type: emitLE"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitLESint8(const SourceInfo &L) { return emitOp<>(OP_LESint8, L); } bool ByteCodeEmitter::emitLEUint8(const SourceInfo &L) { return emitOp<>(OP_LEUint8, L); } bool ByteCodeEmitter::emitLESint16(const SourceInfo &L) { return emitOp<>(OP_LESint16, L); } bool ByteCodeEmitter::emitLEUint16(const SourceInfo &L) { return emitOp<>(OP_LEUint16, L); } bool ByteCodeEmitter::emitLESint32(const SourceInfo &L) { return emitOp<>(OP_LESint32, L); } bool ByteCodeEmitter::emitLEUint32(const SourceInfo &L) { return emitOp<>(OP_LEUint32, L); } bool ByteCodeEmitter::emitLESint64(const SourceInfo &L) { return emitOp<>(OP_LESint64, L); } bool ByteCodeEmitter::emitLEUint64(const SourceInfo &L) { return emitOp<>(OP_LEUint64, L); } bool ByteCodeEmitter::emitLEIntAP(const SourceInfo &L) { return emitOp<>(OP_LEIntAP, L); } bool ByteCodeEmitter::emitLEIntAPS(const SourceInfo &L) { return emitOp<>(OP_LEIntAPS, L); } bool ByteCodeEmitter::emitLEBool(const SourceInfo &L) { return emitOp<>(OP_LEBool, L); } bool ByteCodeEmitter::emitLEFixedPoint(const SourceInfo &L) { return emitOp<>(OP_LEFixedPoint, L); } bool ByteCodeEmitter::emitLEPtr(const SourceInfo &L) { return emitOp<>(OP_LEPtr, L); } bool ByteCodeEmitter::emitLEFloat(const SourceInfo &L) { return emitOp<>(OP_LEFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitLESint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLESint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLESint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLESint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } bool EvalEmitter::emitLEFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LE(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_LTSint8, OP_LTUint8, OP_LTSint16, OP_LTUint16, OP_LTSint32, OP_LTUint32, OP_LTSint64, OP_LTUint64, OP_LTIntAP, OP_LTIntAPS, OP_LTBool, OP_LTFixedPoint, OP_LTPtr, OP_LTFloat, #endif #ifdef GET_INTERP case OP_LTSint8: { if (!LT(S, OpPC)) return false; continue; } case OP_LTUint8: { if (!LT(S, OpPC)) return false; continue; } case OP_LTSint16: { if (!LT(S, OpPC)) return false; continue; } case OP_LTUint16: { if (!LT(S, OpPC)) return false; continue; } case OP_LTSint32: { if (!LT(S, OpPC)) return false; continue; } case OP_LTUint32: { if (!LT(S, OpPC)) return false; continue; } case OP_LTSint64: { if (!LT(S, OpPC)) return false; continue; } case OP_LTUint64: { if (!LT(S, OpPC)) return false; continue; } case OP_LTIntAP: { if (!LT(S, OpPC)) return false; continue; } case OP_LTIntAPS: { if (!LT(S, OpPC)) return false; continue; } case OP_LTBool: { if (!LT(S, OpPC)) return false; continue; } case OP_LTFixedPoint: { if (!LT(S, OpPC)) return false; continue; } case OP_LTPtr: { if (!LT(S, OpPC)) return false; continue; } case OP_LTFloat: { if (!LT(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_LTSint8: Text.Op = PrintName("LTSint8"); break; case OP_LTUint8: Text.Op = PrintName("LTUint8"); break; case OP_LTSint16: Text.Op = PrintName("LTSint16"); break; case OP_LTUint16: Text.Op = PrintName("LTUint16"); break; case OP_LTSint32: Text.Op = PrintName("LTSint32"); break; case OP_LTUint32: Text.Op = PrintName("LTUint32"); break; case OP_LTSint64: Text.Op = PrintName("LTSint64"); break; case OP_LTUint64: Text.Op = PrintName("LTUint64"); break; case OP_LTIntAP: Text.Op = PrintName("LTIntAP"); break; case OP_LTIntAPS: Text.Op = PrintName("LTIntAPS"); break; case OP_LTBool: Text.Op = PrintName("LTBool"); break; case OP_LTFixedPoint: Text.Op = PrintName("LTFixedPoint"); break; case OP_LTPtr: Text.Op = PrintName("LTPtr"); break; case OP_LTFloat: Text.Op = PrintName("LTFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitLTSint8(const SourceInfo &); bool emitLTUint8(const SourceInfo &); bool emitLTSint16(const SourceInfo &); bool emitLTUint16(const SourceInfo &); bool emitLTSint32(const SourceInfo &); bool emitLTUint32(const SourceInfo &); bool emitLTSint64(const SourceInfo &); bool emitLTUint64(const SourceInfo &); bool emitLTIntAP(const SourceInfo &); bool emitLTIntAPS(const SourceInfo &); bool emitLTBool(const SourceInfo &); bool emitLTFixedPoint(const SourceInfo &); bool emitLTPtr(const SourceInfo &); bool emitLTFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitLT(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitLT(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitLTSint8(I); case PT_Uint8: return emitLTUint8(I); case PT_Sint16: return emitLTSint16(I); case PT_Uint16: return emitLTUint16(I); case PT_Sint32: return emitLTSint32(I); case PT_Uint32: return emitLTUint32(I); case PT_Sint64: return emitLTSint64(I); case PT_Uint64: return emitLTUint64(I); case PT_IntAP: return emitLTIntAP(I); case PT_IntAPS: return emitLTIntAPS(I); case PT_Bool: return emitLTBool(I); case PT_FixedPoint: return emitLTFixedPoint(I); case PT_Ptr: return emitLTPtr(I); case PT_Float: return emitLTFloat(I); default: llvm_unreachable("invalid type: emitLT"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitLTSint8(const SourceInfo &L) { return emitOp<>(OP_LTSint8, L); } bool ByteCodeEmitter::emitLTUint8(const SourceInfo &L) { return emitOp<>(OP_LTUint8, L); } bool ByteCodeEmitter::emitLTSint16(const SourceInfo &L) { return emitOp<>(OP_LTSint16, L); } bool ByteCodeEmitter::emitLTUint16(const SourceInfo &L) { return emitOp<>(OP_LTUint16, L); } bool ByteCodeEmitter::emitLTSint32(const SourceInfo &L) { return emitOp<>(OP_LTSint32, L); } bool ByteCodeEmitter::emitLTUint32(const SourceInfo &L) { return emitOp<>(OP_LTUint32, L); } bool ByteCodeEmitter::emitLTSint64(const SourceInfo &L) { return emitOp<>(OP_LTSint64, L); } bool ByteCodeEmitter::emitLTUint64(const SourceInfo &L) { return emitOp<>(OP_LTUint64, L); } bool ByteCodeEmitter::emitLTIntAP(const SourceInfo &L) { return emitOp<>(OP_LTIntAP, L); } bool ByteCodeEmitter::emitLTIntAPS(const SourceInfo &L) { return emitOp<>(OP_LTIntAPS, L); } bool ByteCodeEmitter::emitLTBool(const SourceInfo &L) { return emitOp<>(OP_LTBool, L); } bool ByteCodeEmitter::emitLTFixedPoint(const SourceInfo &L) { return emitOp<>(OP_LTFixedPoint, L); } bool ByteCodeEmitter::emitLTPtr(const SourceInfo &L) { return emitOp<>(OP_LTPtr, L); } bool ByteCodeEmitter::emitLTFloat(const SourceInfo &L) { return emitOp<>(OP_LTFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitLTSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } bool EvalEmitter::emitLTFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LT(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_LoadSint8, OP_LoadUint8, OP_LoadSint16, OP_LoadUint16, OP_LoadSint32, OP_LoadUint32, OP_LoadSint64, OP_LoadUint64, OP_LoadIntAP, OP_LoadIntAPS, OP_LoadBool, OP_LoadFixedPoint, OP_LoadPtr, OP_LoadMemberPtr, OP_LoadFloat, #endif #ifdef GET_INTERP case OP_LoadSint8: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadUint8: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadSint16: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadUint16: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadSint32: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadUint32: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadSint64: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadUint64: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadIntAP: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadIntAPS: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadBool: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadFixedPoint: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadPtr: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadMemberPtr: { if (!Load(S, OpPC)) return false; continue; } case OP_LoadFloat: { if (!Load(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_LoadSint8: Text.Op = PrintName("LoadSint8"); break; case OP_LoadUint8: Text.Op = PrintName("LoadUint8"); break; case OP_LoadSint16: Text.Op = PrintName("LoadSint16"); break; case OP_LoadUint16: Text.Op = PrintName("LoadUint16"); break; case OP_LoadSint32: Text.Op = PrintName("LoadSint32"); break; case OP_LoadUint32: Text.Op = PrintName("LoadUint32"); break; case OP_LoadSint64: Text.Op = PrintName("LoadSint64"); break; case OP_LoadUint64: Text.Op = PrintName("LoadUint64"); break; case OP_LoadIntAP: Text.Op = PrintName("LoadIntAP"); break; case OP_LoadIntAPS: Text.Op = PrintName("LoadIntAPS"); break; case OP_LoadBool: Text.Op = PrintName("LoadBool"); break; case OP_LoadFixedPoint: Text.Op = PrintName("LoadFixedPoint"); break; case OP_LoadPtr: Text.Op = PrintName("LoadPtr"); break; case OP_LoadMemberPtr: Text.Op = PrintName("LoadMemberPtr"); break; case OP_LoadFloat: Text.Op = PrintName("LoadFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitLoadSint8(const SourceInfo &); bool emitLoadUint8(const SourceInfo &); bool emitLoadSint16(const SourceInfo &); bool emitLoadUint16(const SourceInfo &); bool emitLoadSint32(const SourceInfo &); bool emitLoadUint32(const SourceInfo &); bool emitLoadSint64(const SourceInfo &); bool emitLoadUint64(const SourceInfo &); bool emitLoadIntAP(const SourceInfo &); bool emitLoadIntAPS(const SourceInfo &); bool emitLoadBool(const SourceInfo &); bool emitLoadFixedPoint(const SourceInfo &); bool emitLoadPtr(const SourceInfo &); bool emitLoadMemberPtr(const SourceInfo &); bool emitLoadFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitLoad(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitLoad(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitLoadSint8(I); case PT_Uint8: return emitLoadUint8(I); case PT_Sint16: return emitLoadSint16(I); case PT_Uint16: return emitLoadUint16(I); case PT_Sint32: return emitLoadSint32(I); case PT_Uint32: return emitLoadUint32(I); case PT_Sint64: return emitLoadSint64(I); case PT_Uint64: return emitLoadUint64(I); case PT_IntAP: return emitLoadIntAP(I); case PT_IntAPS: return emitLoadIntAPS(I); case PT_Bool: return emitLoadBool(I); case PT_FixedPoint: return emitLoadFixedPoint(I); case PT_Ptr: return emitLoadPtr(I); case PT_MemberPtr: return emitLoadMemberPtr(I); case PT_Float: return emitLoadFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitLoadSint8(const SourceInfo &L) { return emitOp<>(OP_LoadSint8, L); } bool ByteCodeEmitter::emitLoadUint8(const SourceInfo &L) { return emitOp<>(OP_LoadUint8, L); } bool ByteCodeEmitter::emitLoadSint16(const SourceInfo &L) { return emitOp<>(OP_LoadSint16, L); } bool ByteCodeEmitter::emitLoadUint16(const SourceInfo &L) { return emitOp<>(OP_LoadUint16, L); } bool ByteCodeEmitter::emitLoadSint32(const SourceInfo &L) { return emitOp<>(OP_LoadSint32, L); } bool ByteCodeEmitter::emitLoadUint32(const SourceInfo &L) { return emitOp<>(OP_LoadUint32, L); } bool ByteCodeEmitter::emitLoadSint64(const SourceInfo &L) { return emitOp<>(OP_LoadSint64, L); } bool ByteCodeEmitter::emitLoadUint64(const SourceInfo &L) { return emitOp<>(OP_LoadUint64, L); } bool ByteCodeEmitter::emitLoadIntAP(const SourceInfo &L) { return emitOp<>(OP_LoadIntAP, L); } bool ByteCodeEmitter::emitLoadIntAPS(const SourceInfo &L) { return emitOp<>(OP_LoadIntAPS, L); } bool ByteCodeEmitter::emitLoadBool(const SourceInfo &L) { return emitOp<>(OP_LoadBool, L); } bool ByteCodeEmitter::emitLoadFixedPoint(const SourceInfo &L) { return emitOp<>(OP_LoadFixedPoint, L); } bool ByteCodeEmitter::emitLoadPtr(const SourceInfo &L) { return emitOp<>(OP_LoadPtr, L); } bool ByteCodeEmitter::emitLoadMemberPtr(const SourceInfo &L) { return emitOp<>(OP_LoadMemberPtr, L); } bool ByteCodeEmitter::emitLoadFloat(const SourceInfo &L) { return emitOp<>(OP_LoadFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitLoadSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } bool EvalEmitter::emitLoadFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Load(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_LoadPopSint8, OP_LoadPopUint8, OP_LoadPopSint16, OP_LoadPopUint16, OP_LoadPopSint32, OP_LoadPopUint32, OP_LoadPopSint64, OP_LoadPopUint64, OP_LoadPopIntAP, OP_LoadPopIntAPS, OP_LoadPopBool, OP_LoadPopFixedPoint, OP_LoadPopPtr, OP_LoadPopMemberPtr, OP_LoadPopFloat, #endif #ifdef GET_INTERP case OP_LoadPopSint8: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopUint8: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopSint16: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopUint16: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopSint32: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopUint32: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopSint64: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopUint64: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopIntAP: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopIntAPS: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopBool: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopFixedPoint: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopPtr: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopMemberPtr: { if (!LoadPop(S, OpPC)) return false; continue; } case OP_LoadPopFloat: { if (!LoadPop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_LoadPopSint8: Text.Op = PrintName("LoadPopSint8"); break; case OP_LoadPopUint8: Text.Op = PrintName("LoadPopUint8"); break; case OP_LoadPopSint16: Text.Op = PrintName("LoadPopSint16"); break; case OP_LoadPopUint16: Text.Op = PrintName("LoadPopUint16"); break; case OP_LoadPopSint32: Text.Op = PrintName("LoadPopSint32"); break; case OP_LoadPopUint32: Text.Op = PrintName("LoadPopUint32"); break; case OP_LoadPopSint64: Text.Op = PrintName("LoadPopSint64"); break; case OP_LoadPopUint64: Text.Op = PrintName("LoadPopUint64"); break; case OP_LoadPopIntAP: Text.Op = PrintName("LoadPopIntAP"); break; case OP_LoadPopIntAPS: Text.Op = PrintName("LoadPopIntAPS"); break; case OP_LoadPopBool: Text.Op = PrintName("LoadPopBool"); break; case OP_LoadPopFixedPoint: Text.Op = PrintName("LoadPopFixedPoint"); break; case OP_LoadPopPtr: Text.Op = PrintName("LoadPopPtr"); break; case OP_LoadPopMemberPtr: Text.Op = PrintName("LoadPopMemberPtr"); break; case OP_LoadPopFloat: Text.Op = PrintName("LoadPopFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitLoadPopSint8(const SourceInfo &); bool emitLoadPopUint8(const SourceInfo &); bool emitLoadPopSint16(const SourceInfo &); bool emitLoadPopUint16(const SourceInfo &); bool emitLoadPopSint32(const SourceInfo &); bool emitLoadPopUint32(const SourceInfo &); bool emitLoadPopSint64(const SourceInfo &); bool emitLoadPopUint64(const SourceInfo &); bool emitLoadPopIntAP(const SourceInfo &); bool emitLoadPopIntAPS(const SourceInfo &); bool emitLoadPopBool(const SourceInfo &); bool emitLoadPopFixedPoint(const SourceInfo &); bool emitLoadPopPtr(const SourceInfo &); bool emitLoadPopMemberPtr(const SourceInfo &); bool emitLoadPopFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitLoadPop(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitLoadPop(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitLoadPopSint8(I); case PT_Uint8: return emitLoadPopUint8(I); case PT_Sint16: return emitLoadPopSint16(I); case PT_Uint16: return emitLoadPopUint16(I); case PT_Sint32: return emitLoadPopSint32(I); case PT_Uint32: return emitLoadPopUint32(I); case PT_Sint64: return emitLoadPopSint64(I); case PT_Uint64: return emitLoadPopUint64(I); case PT_IntAP: return emitLoadPopIntAP(I); case PT_IntAPS: return emitLoadPopIntAPS(I); case PT_Bool: return emitLoadPopBool(I); case PT_FixedPoint: return emitLoadPopFixedPoint(I); case PT_Ptr: return emitLoadPopPtr(I); case PT_MemberPtr: return emitLoadPopMemberPtr(I); case PT_Float: return emitLoadPopFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitLoadPopSint8(const SourceInfo &L) { return emitOp<>(OP_LoadPopSint8, L); } bool ByteCodeEmitter::emitLoadPopUint8(const SourceInfo &L) { return emitOp<>(OP_LoadPopUint8, L); } bool ByteCodeEmitter::emitLoadPopSint16(const SourceInfo &L) { return emitOp<>(OP_LoadPopSint16, L); } bool ByteCodeEmitter::emitLoadPopUint16(const SourceInfo &L) { return emitOp<>(OP_LoadPopUint16, L); } bool ByteCodeEmitter::emitLoadPopSint32(const SourceInfo &L) { return emitOp<>(OP_LoadPopSint32, L); } bool ByteCodeEmitter::emitLoadPopUint32(const SourceInfo &L) { return emitOp<>(OP_LoadPopUint32, L); } bool ByteCodeEmitter::emitLoadPopSint64(const SourceInfo &L) { return emitOp<>(OP_LoadPopSint64, L); } bool ByteCodeEmitter::emitLoadPopUint64(const SourceInfo &L) { return emitOp<>(OP_LoadPopUint64, L); } bool ByteCodeEmitter::emitLoadPopIntAP(const SourceInfo &L) { return emitOp<>(OP_LoadPopIntAP, L); } bool ByteCodeEmitter::emitLoadPopIntAPS(const SourceInfo &L) { return emitOp<>(OP_LoadPopIntAPS, L); } bool ByteCodeEmitter::emitLoadPopBool(const SourceInfo &L) { return emitOp<>(OP_LoadPopBool, L); } bool ByteCodeEmitter::emitLoadPopFixedPoint(const SourceInfo &L) { return emitOp<>(OP_LoadPopFixedPoint, L); } bool ByteCodeEmitter::emitLoadPopPtr(const SourceInfo &L) { return emitOp<>(OP_LoadPopPtr, L); } bool ByteCodeEmitter::emitLoadPopMemberPtr(const SourceInfo &L) { return emitOp<>(OP_LoadPopMemberPtr, L); } bool ByteCodeEmitter::emitLoadPopFloat(const SourceInfo &L) { return emitOp<>(OP_LoadPopFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitLoadPopSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } bool EvalEmitter::emitLoadPopFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return LoadPop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Memcpy, #endif #ifdef GET_INTERP case OP_Memcpy: { if (!Memcpy(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_Memcpy: Text.Op = PrintName("Memcpy"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitMemcpy(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitMemcpy(const SourceInfo &L) { return emitOp<>(OP_Memcpy, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitMemcpy(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Memcpy(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_MulSint8, OP_MulUint8, OP_MulSint16, OP_MulUint16, OP_MulSint32, OP_MulUint32, OP_MulSint64, OP_MulUint64, OP_MulIntAP, OP_MulIntAPS, OP_MulBool, OP_MulFixedPoint, #endif #ifdef GET_INTERP case OP_MulSint8: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulUint8: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulSint16: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulUint16: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulSint32: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulUint32: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulSint64: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulUint64: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulIntAP: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulIntAPS: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulBool: { if (!Mul(S, OpPC)) return false; continue; } case OP_MulFixedPoint: { if (!Mul(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_MulSint8: Text.Op = PrintName("MulSint8"); break; case OP_MulUint8: Text.Op = PrintName("MulUint8"); break; case OP_MulSint16: Text.Op = PrintName("MulSint16"); break; case OP_MulUint16: Text.Op = PrintName("MulUint16"); break; case OP_MulSint32: Text.Op = PrintName("MulSint32"); break; case OP_MulUint32: Text.Op = PrintName("MulUint32"); break; case OP_MulSint64: Text.Op = PrintName("MulSint64"); break; case OP_MulUint64: Text.Op = PrintName("MulUint64"); break; case OP_MulIntAP: Text.Op = PrintName("MulIntAP"); break; case OP_MulIntAPS: Text.Op = PrintName("MulIntAPS"); break; case OP_MulBool: Text.Op = PrintName("MulBool"); break; case OP_MulFixedPoint: Text.Op = PrintName("MulFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitMulSint8(const SourceInfo &); bool emitMulUint8(const SourceInfo &); bool emitMulSint16(const SourceInfo &); bool emitMulUint16(const SourceInfo &); bool emitMulSint32(const SourceInfo &); bool emitMulUint32(const SourceInfo &); bool emitMulSint64(const SourceInfo &); bool emitMulUint64(const SourceInfo &); bool emitMulIntAP(const SourceInfo &); bool emitMulIntAPS(const SourceInfo &); bool emitMulBool(const SourceInfo &); bool emitMulFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitMul(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitMul(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitMulSint8(I); case PT_Uint8: return emitMulUint8(I); case PT_Sint16: return emitMulSint16(I); case PT_Uint16: return emitMulUint16(I); case PT_Sint32: return emitMulSint32(I); case PT_Uint32: return emitMulUint32(I); case PT_Sint64: return emitMulSint64(I); case PT_Uint64: return emitMulUint64(I); case PT_IntAP: return emitMulIntAP(I); case PT_IntAPS: return emitMulIntAPS(I); case PT_Bool: return emitMulBool(I); case PT_FixedPoint: return emitMulFixedPoint(I); default: llvm_unreachable("invalid type: emitMul"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitMulSint8(const SourceInfo &L) { return emitOp<>(OP_MulSint8, L); } bool ByteCodeEmitter::emitMulUint8(const SourceInfo &L) { return emitOp<>(OP_MulUint8, L); } bool ByteCodeEmitter::emitMulSint16(const SourceInfo &L) { return emitOp<>(OP_MulSint16, L); } bool ByteCodeEmitter::emitMulUint16(const SourceInfo &L) { return emitOp<>(OP_MulUint16, L); } bool ByteCodeEmitter::emitMulSint32(const SourceInfo &L) { return emitOp<>(OP_MulSint32, L); } bool ByteCodeEmitter::emitMulUint32(const SourceInfo &L) { return emitOp<>(OP_MulUint32, L); } bool ByteCodeEmitter::emitMulSint64(const SourceInfo &L) { return emitOp<>(OP_MulSint64, L); } bool ByteCodeEmitter::emitMulUint64(const SourceInfo &L) { return emitOp<>(OP_MulUint64, L); } bool ByteCodeEmitter::emitMulIntAP(const SourceInfo &L) { return emitOp<>(OP_MulIntAP, L); } bool ByteCodeEmitter::emitMulIntAPS(const SourceInfo &L) { return emitOp<>(OP_MulIntAPS, L); } bool ByteCodeEmitter::emitMulBool(const SourceInfo &L) { return emitOp<>(OP_MulBool, L); } bool ByteCodeEmitter::emitMulFixedPoint(const SourceInfo &L) { return emitOp<>(OP_MulFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitMulSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } bool EvalEmitter::emitMulFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mul(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_MulcSint8, OP_MulcUint8, OP_MulcSint16, OP_MulcUint16, OP_MulcSint32, OP_MulcUint32, OP_MulcSint64, OP_MulcUint64, OP_MulcIntAP, OP_MulcIntAPS, OP_MulcFloat, #endif #ifdef GET_INTERP case OP_MulcSint8: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcUint8: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcSint16: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcUint16: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcSint32: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcUint32: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcSint64: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcUint64: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcIntAP: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcIntAPS: { if (!Mulc(S, OpPC)) return false; continue; } case OP_MulcFloat: { if (!Mulc(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_MulcSint8: Text.Op = PrintName("MulcSint8"); break; case OP_MulcUint8: Text.Op = PrintName("MulcUint8"); break; case OP_MulcSint16: Text.Op = PrintName("MulcSint16"); break; case OP_MulcUint16: Text.Op = PrintName("MulcUint16"); break; case OP_MulcSint32: Text.Op = PrintName("MulcSint32"); break; case OP_MulcUint32: Text.Op = PrintName("MulcUint32"); break; case OP_MulcSint64: Text.Op = PrintName("MulcSint64"); break; case OP_MulcUint64: Text.Op = PrintName("MulcUint64"); break; case OP_MulcIntAP: Text.Op = PrintName("MulcIntAP"); break; case OP_MulcIntAPS: Text.Op = PrintName("MulcIntAPS"); break; case OP_MulcFloat: Text.Op = PrintName("MulcFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitMulcSint8(const SourceInfo &); bool emitMulcUint8(const SourceInfo &); bool emitMulcSint16(const SourceInfo &); bool emitMulcUint16(const SourceInfo &); bool emitMulcSint32(const SourceInfo &); bool emitMulcUint32(const SourceInfo &); bool emitMulcSint64(const SourceInfo &); bool emitMulcUint64(const SourceInfo &); bool emitMulcIntAP(const SourceInfo &); bool emitMulcIntAPS(const SourceInfo &); bool emitMulcFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitMulc(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitMulc(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitMulcSint8(I); case PT_Uint8: return emitMulcUint8(I); case PT_Sint16: return emitMulcSint16(I); case PT_Uint16: return emitMulcUint16(I); case PT_Sint32: return emitMulcSint32(I); case PT_Uint32: return emitMulcUint32(I); case PT_Sint64: return emitMulcSint64(I); case PT_Uint64: return emitMulcUint64(I); case PT_IntAP: return emitMulcIntAP(I); case PT_IntAPS: return emitMulcIntAPS(I); case PT_Float: return emitMulcFloat(I); default: llvm_unreachable("invalid type: emitMulc"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitMulcSint8(const SourceInfo &L) { return emitOp<>(OP_MulcSint8, L); } bool ByteCodeEmitter::emitMulcUint8(const SourceInfo &L) { return emitOp<>(OP_MulcUint8, L); } bool ByteCodeEmitter::emitMulcSint16(const SourceInfo &L) { return emitOp<>(OP_MulcSint16, L); } bool ByteCodeEmitter::emitMulcUint16(const SourceInfo &L) { return emitOp<>(OP_MulcUint16, L); } bool ByteCodeEmitter::emitMulcSint32(const SourceInfo &L) { return emitOp<>(OP_MulcSint32, L); } bool ByteCodeEmitter::emitMulcUint32(const SourceInfo &L) { return emitOp<>(OP_MulcUint32, L); } bool ByteCodeEmitter::emitMulcSint64(const SourceInfo &L) { return emitOp<>(OP_MulcSint64, L); } bool ByteCodeEmitter::emitMulcUint64(const SourceInfo &L) { return emitOp<>(OP_MulcUint64, L); } bool ByteCodeEmitter::emitMulcIntAP(const SourceInfo &L) { return emitOp<>(OP_MulcIntAP, L); } bool ByteCodeEmitter::emitMulcIntAPS(const SourceInfo &L) { return emitOp<>(OP_MulcIntAPS, L); } bool ByteCodeEmitter::emitMulcFloat(const SourceInfo &L) { return emitOp<>(OP_MulcFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitMulcSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } bool EvalEmitter::emitMulcFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulc(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Mulf, #endif #ifdef GET_INTERP case OP_Mulf: { const auto V0 = ReadArg(S, PC); if (!Mulf(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Mulf: Text.Op = PrintName("Mulf"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitMulf( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitMulf( uint32_t A0, const SourceInfo &L) { return emitOp(OP_Mulf, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitMulf( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Mulf(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_NESint8, OP_NEUint8, OP_NESint16, OP_NEUint16, OP_NESint32, OP_NEUint32, OP_NESint64, OP_NEUint64, OP_NEIntAP, OP_NEIntAPS, OP_NEBool, OP_NEFixedPoint, OP_NEPtr, OP_NEMemberPtr, OP_NEFloat, #endif #ifdef GET_INTERP case OP_NESint8: { if (!NE(S, OpPC)) return false; continue; } case OP_NEUint8: { if (!NE(S, OpPC)) return false; continue; } case OP_NESint16: { if (!NE(S, OpPC)) return false; continue; } case OP_NEUint16: { if (!NE(S, OpPC)) return false; continue; } case OP_NESint32: { if (!NE(S, OpPC)) return false; continue; } case OP_NEUint32: { if (!NE(S, OpPC)) return false; continue; } case OP_NESint64: { if (!NE(S, OpPC)) return false; continue; } case OP_NEUint64: { if (!NE(S, OpPC)) return false; continue; } case OP_NEIntAP: { if (!NE(S, OpPC)) return false; continue; } case OP_NEIntAPS: { if (!NE(S, OpPC)) return false; continue; } case OP_NEBool: { if (!NE(S, OpPC)) return false; continue; } case OP_NEFixedPoint: { if (!NE(S, OpPC)) return false; continue; } case OP_NEPtr: { if (!NE(S, OpPC)) return false; continue; } case OP_NEMemberPtr: { if (!NE(S, OpPC)) return false; continue; } case OP_NEFloat: { if (!NE(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_NESint8: Text.Op = PrintName("NESint8"); break; case OP_NEUint8: Text.Op = PrintName("NEUint8"); break; case OP_NESint16: Text.Op = PrintName("NESint16"); break; case OP_NEUint16: Text.Op = PrintName("NEUint16"); break; case OP_NESint32: Text.Op = PrintName("NESint32"); break; case OP_NEUint32: Text.Op = PrintName("NEUint32"); break; case OP_NESint64: Text.Op = PrintName("NESint64"); break; case OP_NEUint64: Text.Op = PrintName("NEUint64"); break; case OP_NEIntAP: Text.Op = PrintName("NEIntAP"); break; case OP_NEIntAPS: Text.Op = PrintName("NEIntAPS"); break; case OP_NEBool: Text.Op = PrintName("NEBool"); break; case OP_NEFixedPoint: Text.Op = PrintName("NEFixedPoint"); break; case OP_NEPtr: Text.Op = PrintName("NEPtr"); break; case OP_NEMemberPtr: Text.Op = PrintName("NEMemberPtr"); break; case OP_NEFloat: Text.Op = PrintName("NEFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitNESint8(const SourceInfo &); bool emitNEUint8(const SourceInfo &); bool emitNESint16(const SourceInfo &); bool emitNEUint16(const SourceInfo &); bool emitNESint32(const SourceInfo &); bool emitNEUint32(const SourceInfo &); bool emitNESint64(const SourceInfo &); bool emitNEUint64(const SourceInfo &); bool emitNEIntAP(const SourceInfo &); bool emitNEIntAPS(const SourceInfo &); bool emitNEBool(const SourceInfo &); bool emitNEFixedPoint(const SourceInfo &); bool emitNEPtr(const SourceInfo &); bool emitNEMemberPtr(const SourceInfo &); bool emitNEFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitNE(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitNE(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitNESint8(I); case PT_Uint8: return emitNEUint8(I); case PT_Sint16: return emitNESint16(I); case PT_Uint16: return emitNEUint16(I); case PT_Sint32: return emitNESint32(I); case PT_Uint32: return emitNEUint32(I); case PT_Sint64: return emitNESint64(I); case PT_Uint64: return emitNEUint64(I); case PT_IntAP: return emitNEIntAP(I); case PT_IntAPS: return emitNEIntAPS(I); case PT_Bool: return emitNEBool(I); case PT_FixedPoint: return emitNEFixedPoint(I); case PT_Ptr: return emitNEPtr(I); case PT_MemberPtr: return emitNEMemberPtr(I); case PT_Float: return emitNEFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitNESint8(const SourceInfo &L) { return emitOp<>(OP_NESint8, L); } bool ByteCodeEmitter::emitNEUint8(const SourceInfo &L) { return emitOp<>(OP_NEUint8, L); } bool ByteCodeEmitter::emitNESint16(const SourceInfo &L) { return emitOp<>(OP_NESint16, L); } bool ByteCodeEmitter::emitNEUint16(const SourceInfo &L) { return emitOp<>(OP_NEUint16, L); } bool ByteCodeEmitter::emitNESint32(const SourceInfo &L) { return emitOp<>(OP_NESint32, L); } bool ByteCodeEmitter::emitNEUint32(const SourceInfo &L) { return emitOp<>(OP_NEUint32, L); } bool ByteCodeEmitter::emitNESint64(const SourceInfo &L) { return emitOp<>(OP_NESint64, L); } bool ByteCodeEmitter::emitNEUint64(const SourceInfo &L) { return emitOp<>(OP_NEUint64, L); } bool ByteCodeEmitter::emitNEIntAP(const SourceInfo &L) { return emitOp<>(OP_NEIntAP, L); } bool ByteCodeEmitter::emitNEIntAPS(const SourceInfo &L) { return emitOp<>(OP_NEIntAPS, L); } bool ByteCodeEmitter::emitNEBool(const SourceInfo &L) { return emitOp<>(OP_NEBool, L); } bool ByteCodeEmitter::emitNEFixedPoint(const SourceInfo &L) { return emitOp<>(OP_NEFixedPoint, L); } bool ByteCodeEmitter::emitNEPtr(const SourceInfo &L) { return emitOp<>(OP_NEPtr, L); } bool ByteCodeEmitter::emitNEMemberPtr(const SourceInfo &L) { return emitOp<>(OP_NEMemberPtr, L); } bool ByteCodeEmitter::emitNEFloat(const SourceInfo &L) { return emitOp<>(OP_NEFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitNESint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNESint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNESint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNESint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } bool EvalEmitter::emitNEFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NE(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_NarrowPtr, #endif #ifdef GET_INTERP case OP_NarrowPtr: { if (!NarrowPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_NarrowPtr: Text.Op = PrintName("NarrowPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitNarrowPtr(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitNarrowPtr(const SourceInfo &L) { return emitOp<>(OP_NarrowPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitNarrowPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NarrowPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_NegSint8, OP_NegUint8, OP_NegSint16, OP_NegUint16, OP_NegSint32, OP_NegUint32, OP_NegSint64, OP_NegUint64, OP_NegIntAP, OP_NegIntAPS, OP_NegBool, OP_NegFloat, OP_NegFixedPoint, #endif #ifdef GET_INTERP case OP_NegSint8: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegUint8: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegSint16: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegUint16: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegSint32: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegUint32: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegSint64: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegUint64: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegIntAP: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegIntAPS: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegBool: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegFloat: { if (!Neg(S, OpPC)) return false; continue; } case OP_NegFixedPoint: { if (!Neg(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_NegSint8: Text.Op = PrintName("NegSint8"); break; case OP_NegUint8: Text.Op = PrintName("NegUint8"); break; case OP_NegSint16: Text.Op = PrintName("NegSint16"); break; case OP_NegUint16: Text.Op = PrintName("NegUint16"); break; case OP_NegSint32: Text.Op = PrintName("NegSint32"); break; case OP_NegUint32: Text.Op = PrintName("NegUint32"); break; case OP_NegSint64: Text.Op = PrintName("NegSint64"); break; case OP_NegUint64: Text.Op = PrintName("NegUint64"); break; case OP_NegIntAP: Text.Op = PrintName("NegIntAP"); break; case OP_NegIntAPS: Text.Op = PrintName("NegIntAPS"); break; case OP_NegBool: Text.Op = PrintName("NegBool"); break; case OP_NegFloat: Text.Op = PrintName("NegFloat"); break; case OP_NegFixedPoint: Text.Op = PrintName("NegFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitNegSint8(const SourceInfo &); bool emitNegUint8(const SourceInfo &); bool emitNegSint16(const SourceInfo &); bool emitNegUint16(const SourceInfo &); bool emitNegSint32(const SourceInfo &); bool emitNegUint32(const SourceInfo &); bool emitNegSint64(const SourceInfo &); bool emitNegUint64(const SourceInfo &); bool emitNegIntAP(const SourceInfo &); bool emitNegIntAPS(const SourceInfo &); bool emitNegBool(const SourceInfo &); bool emitNegFloat(const SourceInfo &); bool emitNegFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitNeg(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitNeg(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitNegSint8(I); case PT_Uint8: return emitNegUint8(I); case PT_Sint16: return emitNegSint16(I); case PT_Uint16: return emitNegUint16(I); case PT_Sint32: return emitNegSint32(I); case PT_Uint32: return emitNegUint32(I); case PT_Sint64: return emitNegSint64(I); case PT_Uint64: return emitNegUint64(I); case PT_IntAP: return emitNegIntAP(I); case PT_IntAPS: return emitNegIntAPS(I); case PT_Bool: return emitNegBool(I); case PT_Float: return emitNegFloat(I); case PT_FixedPoint: return emitNegFixedPoint(I); default: llvm_unreachable("invalid type: emitNeg"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitNegSint8(const SourceInfo &L) { return emitOp<>(OP_NegSint8, L); } bool ByteCodeEmitter::emitNegUint8(const SourceInfo &L) { return emitOp<>(OP_NegUint8, L); } bool ByteCodeEmitter::emitNegSint16(const SourceInfo &L) { return emitOp<>(OP_NegSint16, L); } bool ByteCodeEmitter::emitNegUint16(const SourceInfo &L) { return emitOp<>(OP_NegUint16, L); } bool ByteCodeEmitter::emitNegSint32(const SourceInfo &L) { return emitOp<>(OP_NegSint32, L); } bool ByteCodeEmitter::emitNegUint32(const SourceInfo &L) { return emitOp<>(OP_NegUint32, L); } bool ByteCodeEmitter::emitNegSint64(const SourceInfo &L) { return emitOp<>(OP_NegSint64, L); } bool ByteCodeEmitter::emitNegUint64(const SourceInfo &L) { return emitOp<>(OP_NegUint64, L); } bool ByteCodeEmitter::emitNegIntAP(const SourceInfo &L) { return emitOp<>(OP_NegIntAP, L); } bool ByteCodeEmitter::emitNegIntAPS(const SourceInfo &L) { return emitOp<>(OP_NegIntAPS, L); } bool ByteCodeEmitter::emitNegBool(const SourceInfo &L) { return emitOp<>(OP_NegBool, L); } bool ByteCodeEmitter::emitNegFloat(const SourceInfo &L) { return emitOp<>(OP_NegFloat, L); } bool ByteCodeEmitter::emitNegFixedPoint(const SourceInfo &L) { return emitOp<>(OP_NegFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitNegSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } bool EvalEmitter::emitNegFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Neg(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_NoRet, #endif #ifdef GET_INTERP case OP_NoRet: { if (!NoRet(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_NoRet: Text.Op = PrintName("NoRet"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitNoRet(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitNoRet(const SourceInfo &L) { return emitOp<>(OP_NoRet, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitNoRet(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return NoRet(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_NullPtr, OP_NullMemberPtr, #endif #ifdef GET_INTERP case OP_NullPtr: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!Null(S, OpPC, V0, V1)) return false; continue; } case OP_NullMemberPtr: { const auto V0 = ReadArg(S, PC); const auto V1 = ReadArg(S, PC); if (!Null(S, OpPC, V0, V1)) return false; continue; } #endif #ifdef GET_DISASM case OP_NullPtr: Text.Op = PrintName("NullPtr"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; case OP_NullMemberPtr: Text.Op = PrintName("NullMemberPtr"); Text.Args.push_back(printArg(P, PC)); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitNullPtr( uint64_t , const Descriptor * , const SourceInfo &); bool emitNullMemberPtr( uint64_t , const Descriptor * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitNull(PrimType, uint64_t, const Descriptor *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitNull(PrimType T0, uint64_t A0, const Descriptor * A1, const SourceInfo &I) { switch (T0) { case PT_Ptr: return emitNullPtr(A0, A1, I); case PT_MemberPtr: return emitNullMemberPtr(A0, A1, I); default: llvm_unreachable("invalid type: emitNull"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitNullPtr( uint64_t A0, const Descriptor * A1, const SourceInfo &L) { return emitOp(OP_NullPtr, A0, A1, L); } bool ByteCodeEmitter::emitNullMemberPtr( uint64_t A0, const Descriptor * A1, const SourceInfo &L) { return emitOp(OP_NullMemberPtr, A0, A1, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitNullPtr( uint64_t A0, const Descriptor * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Null(S, OpPC, A0, A1); } bool EvalEmitter::emitNullMemberPtr( uint64_t A0, const Descriptor * A1, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Null(S, OpPC, A0, A1); } #endif #ifdef GET_OPCODE_NAMES OP_OffsetOfSint8, OP_OffsetOfUint8, OP_OffsetOfSint16, OP_OffsetOfUint16, OP_OffsetOfSint32, OP_OffsetOfUint32, OP_OffsetOfSint64, OP_OffsetOfUint64, OP_OffsetOfIntAP, OP_OffsetOfIntAPS, #endif #ifdef GET_INTERP case OP_OffsetOfSint8: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } case OP_OffsetOfUint8: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } case OP_OffsetOfSint16: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } case OP_OffsetOfUint16: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } case OP_OffsetOfSint32: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } case OP_OffsetOfUint32: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } case OP_OffsetOfSint64: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } case OP_OffsetOfUint64: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } case OP_OffsetOfIntAP: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } case OP_OffsetOfIntAPS: { const auto V0 = ReadArg(S, PC); if (!OffsetOf(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_OffsetOfSint8: Text.Op = PrintName("OffsetOfSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_OffsetOfUint8: Text.Op = PrintName("OffsetOfUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_OffsetOfSint16: Text.Op = PrintName("OffsetOfSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_OffsetOfUint16: Text.Op = PrintName("OffsetOfUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_OffsetOfSint32: Text.Op = PrintName("OffsetOfSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_OffsetOfUint32: Text.Op = PrintName("OffsetOfUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_OffsetOfSint64: Text.Op = PrintName("OffsetOfSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_OffsetOfUint64: Text.Op = PrintName("OffsetOfUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_OffsetOfIntAP: Text.Op = PrintName("OffsetOfIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_OffsetOfIntAPS: Text.Op = PrintName("OffsetOfIntAPS"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitOffsetOfSint8( const OffsetOfExpr * , const SourceInfo &); bool emitOffsetOfUint8( const OffsetOfExpr * , const SourceInfo &); bool emitOffsetOfSint16( const OffsetOfExpr * , const SourceInfo &); bool emitOffsetOfUint16( const OffsetOfExpr * , const SourceInfo &); bool emitOffsetOfSint32( const OffsetOfExpr * , const SourceInfo &); bool emitOffsetOfUint32( const OffsetOfExpr * , const SourceInfo &); bool emitOffsetOfSint64( const OffsetOfExpr * , const SourceInfo &); bool emitOffsetOfUint64( const OffsetOfExpr * , const SourceInfo &); bool emitOffsetOfIntAP( const OffsetOfExpr * , const SourceInfo &); bool emitOffsetOfIntAPS( const OffsetOfExpr * , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitOffsetOf(PrimType, const OffsetOfExpr *, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitOffsetOf(PrimType T0, const OffsetOfExpr * A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitOffsetOfSint8(A0, I); case PT_Uint8: return emitOffsetOfUint8(A0, I); case PT_Sint16: return emitOffsetOfSint16(A0, I); case PT_Uint16: return emitOffsetOfUint16(A0, I); case PT_Sint32: return emitOffsetOfSint32(A0, I); case PT_Uint32: return emitOffsetOfUint32(A0, I); case PT_Sint64: return emitOffsetOfSint64(A0, I); case PT_Uint64: return emitOffsetOfUint64(A0, I); case PT_IntAP: return emitOffsetOfIntAP(A0, I); case PT_IntAPS: return emitOffsetOfIntAPS(A0, I); default: llvm_unreachable("invalid type: emitOffsetOf"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitOffsetOfSint8( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfSint8, A0, L); } bool ByteCodeEmitter::emitOffsetOfUint8( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfUint8, A0, L); } bool ByteCodeEmitter::emitOffsetOfSint16( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfSint16, A0, L); } bool ByteCodeEmitter::emitOffsetOfUint16( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfUint16, A0, L); } bool ByteCodeEmitter::emitOffsetOfSint32( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfSint32, A0, L); } bool ByteCodeEmitter::emitOffsetOfUint32( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfUint32, A0, L); } bool ByteCodeEmitter::emitOffsetOfSint64( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfSint64, A0, L); } bool ByteCodeEmitter::emitOffsetOfUint64( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfUint64, A0, L); } bool ByteCodeEmitter::emitOffsetOfIntAP( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfIntAP, A0, L); } bool ByteCodeEmitter::emitOffsetOfIntAPS( const OffsetOfExpr * A0, const SourceInfo &L) { return emitOp(OP_OffsetOfIntAPS, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitOffsetOfSint8( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } bool EvalEmitter::emitOffsetOfUint8( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } bool EvalEmitter::emitOffsetOfSint16( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } bool EvalEmitter::emitOffsetOfUint16( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } bool EvalEmitter::emitOffsetOfSint32( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } bool EvalEmitter::emitOffsetOfUint32( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } bool EvalEmitter::emitOffsetOfSint64( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } bool EvalEmitter::emitOffsetOfUint64( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } bool EvalEmitter::emitOffsetOfIntAP( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } bool EvalEmitter::emitOffsetOfIntAPS( const OffsetOfExpr * A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return OffsetOf(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_PopSint8, OP_PopUint8, OP_PopSint16, OP_PopUint16, OP_PopSint32, OP_PopUint32, OP_PopSint64, OP_PopUint64, OP_PopIntAP, OP_PopIntAPS, OP_PopBool, OP_PopFixedPoint, OP_PopPtr, OP_PopMemberPtr, OP_PopFloat, #endif #ifdef GET_INTERP case OP_PopSint8: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopUint8: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopSint16: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopUint16: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopSint32: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopUint32: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopSint64: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopUint64: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopIntAP: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopIntAPS: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopBool: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopFixedPoint: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopPtr: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopMemberPtr: { if (!Pop(S, OpPC)) return false; continue; } case OP_PopFloat: { if (!Pop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_PopSint8: Text.Op = PrintName("PopSint8"); break; case OP_PopUint8: Text.Op = PrintName("PopUint8"); break; case OP_PopSint16: Text.Op = PrintName("PopSint16"); break; case OP_PopUint16: Text.Op = PrintName("PopUint16"); break; case OP_PopSint32: Text.Op = PrintName("PopSint32"); break; case OP_PopUint32: Text.Op = PrintName("PopUint32"); break; case OP_PopSint64: Text.Op = PrintName("PopSint64"); break; case OP_PopUint64: Text.Op = PrintName("PopUint64"); break; case OP_PopIntAP: Text.Op = PrintName("PopIntAP"); break; case OP_PopIntAPS: Text.Op = PrintName("PopIntAPS"); break; case OP_PopBool: Text.Op = PrintName("PopBool"); break; case OP_PopFixedPoint: Text.Op = PrintName("PopFixedPoint"); break; case OP_PopPtr: Text.Op = PrintName("PopPtr"); break; case OP_PopMemberPtr: Text.Op = PrintName("PopMemberPtr"); break; case OP_PopFloat: Text.Op = PrintName("PopFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitPopSint8(const SourceInfo &); bool emitPopUint8(const SourceInfo &); bool emitPopSint16(const SourceInfo &); bool emitPopUint16(const SourceInfo &); bool emitPopSint32(const SourceInfo &); bool emitPopUint32(const SourceInfo &); bool emitPopSint64(const SourceInfo &); bool emitPopUint64(const SourceInfo &); bool emitPopIntAP(const SourceInfo &); bool emitPopIntAPS(const SourceInfo &); bool emitPopBool(const SourceInfo &); bool emitPopFixedPoint(const SourceInfo &); bool emitPopPtr(const SourceInfo &); bool emitPopMemberPtr(const SourceInfo &); bool emitPopFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitPop(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitPop(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitPopSint8(I); case PT_Uint8: return emitPopUint8(I); case PT_Sint16: return emitPopSint16(I); case PT_Uint16: return emitPopUint16(I); case PT_Sint32: return emitPopSint32(I); case PT_Uint32: return emitPopUint32(I); case PT_Sint64: return emitPopSint64(I); case PT_Uint64: return emitPopUint64(I); case PT_IntAP: return emitPopIntAP(I); case PT_IntAPS: return emitPopIntAPS(I); case PT_Bool: return emitPopBool(I); case PT_FixedPoint: return emitPopFixedPoint(I); case PT_Ptr: return emitPopPtr(I); case PT_MemberPtr: return emitPopMemberPtr(I); case PT_Float: return emitPopFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitPopSint8(const SourceInfo &L) { return emitOp<>(OP_PopSint8, L); } bool ByteCodeEmitter::emitPopUint8(const SourceInfo &L) { return emitOp<>(OP_PopUint8, L); } bool ByteCodeEmitter::emitPopSint16(const SourceInfo &L) { return emitOp<>(OP_PopSint16, L); } bool ByteCodeEmitter::emitPopUint16(const SourceInfo &L) { return emitOp<>(OP_PopUint16, L); } bool ByteCodeEmitter::emitPopSint32(const SourceInfo &L) { return emitOp<>(OP_PopSint32, L); } bool ByteCodeEmitter::emitPopUint32(const SourceInfo &L) { return emitOp<>(OP_PopUint32, L); } bool ByteCodeEmitter::emitPopSint64(const SourceInfo &L) { return emitOp<>(OP_PopSint64, L); } bool ByteCodeEmitter::emitPopUint64(const SourceInfo &L) { return emitOp<>(OP_PopUint64, L); } bool ByteCodeEmitter::emitPopIntAP(const SourceInfo &L) { return emitOp<>(OP_PopIntAP, L); } bool ByteCodeEmitter::emitPopIntAPS(const SourceInfo &L) { return emitOp<>(OP_PopIntAPS, L); } bool ByteCodeEmitter::emitPopBool(const SourceInfo &L) { return emitOp<>(OP_PopBool, L); } bool ByteCodeEmitter::emitPopFixedPoint(const SourceInfo &L) { return emitOp<>(OP_PopFixedPoint, L); } bool ByteCodeEmitter::emitPopPtr(const SourceInfo &L) { return emitOp<>(OP_PopPtr, L); } bool ByteCodeEmitter::emitPopMemberPtr(const SourceInfo &L) { return emitOp<>(OP_PopMemberPtr, L); } bool ByteCodeEmitter::emitPopFloat(const SourceInfo &L) { return emitOp<>(OP_PopFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitPopSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } bool EvalEmitter::emitPopFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Pop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_PopCC, #endif #ifdef GET_INTERP case OP_PopCC: { if (!PopCC(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_PopCC: Text.Op = PrintName("PopCC"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitPopCC(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitPopCC(const SourceInfo &L) { return emitOp<>(OP_PopCC, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitPopCC(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PopCC(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_PreDecSint8, OP_PreDecUint8, OP_PreDecSint16, OP_PreDecUint16, OP_PreDecSint32, OP_PreDecUint32, OP_PreDecSint64, OP_PreDecUint64, OP_PreDecIntAP, OP_PreDecIntAPS, OP_PreDecBool, OP_PreDecFixedPoint, #endif #ifdef GET_INTERP case OP_PreDecSint8: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecUint8: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecSint16: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecUint16: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecSint32: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecUint32: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecSint64: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecUint64: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecIntAP: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecIntAPS: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecBool: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } case OP_PreDecFixedPoint: { const auto V0 = ReadArg(S, PC); if (!PreDec(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_PreDecSint8: Text.Op = PrintName("PreDecSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecUint8: Text.Op = PrintName("PreDecUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecSint16: Text.Op = PrintName("PreDecSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecUint16: Text.Op = PrintName("PreDecUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecSint32: Text.Op = PrintName("PreDecSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecUint32: Text.Op = PrintName("PreDecUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecSint64: Text.Op = PrintName("PreDecSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecUint64: Text.Op = PrintName("PreDecUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecIntAP: Text.Op = PrintName("PreDecIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecIntAPS: Text.Op = PrintName("PreDecIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecBool: Text.Op = PrintName("PreDecBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreDecFixedPoint: Text.Op = PrintName("PreDecFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitPreDecSint8( bool , const SourceInfo &); bool emitPreDecUint8( bool , const SourceInfo &); bool emitPreDecSint16( bool , const SourceInfo &); bool emitPreDecUint16( bool , const SourceInfo &); bool emitPreDecSint32( bool , const SourceInfo &); bool emitPreDecUint32( bool , const SourceInfo &); bool emitPreDecSint64( bool , const SourceInfo &); bool emitPreDecUint64( bool , const SourceInfo &); bool emitPreDecIntAP( bool , const SourceInfo &); bool emitPreDecIntAPS( bool , const SourceInfo &); bool emitPreDecBool( bool , const SourceInfo &); bool emitPreDecFixedPoint( bool , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitPreDec(PrimType, bool, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitPreDec(PrimType T0, bool A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitPreDecSint8(A0, I); case PT_Uint8: return emitPreDecUint8(A0, I); case PT_Sint16: return emitPreDecSint16(A0, I); case PT_Uint16: return emitPreDecUint16(A0, I); case PT_Sint32: return emitPreDecSint32(A0, I); case PT_Uint32: return emitPreDecUint32(A0, I); case PT_Sint64: return emitPreDecSint64(A0, I); case PT_Uint64: return emitPreDecUint64(A0, I); case PT_IntAP: return emitPreDecIntAP(A0, I); case PT_IntAPS: return emitPreDecIntAPS(A0, I); case PT_Bool: return emitPreDecBool(A0, I); case PT_FixedPoint: return emitPreDecFixedPoint(A0, I); default: llvm_unreachable("invalid type: emitPreDec"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitPreDecSint8( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecSint8, A0, L); } bool ByteCodeEmitter::emitPreDecUint8( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecUint8, A0, L); } bool ByteCodeEmitter::emitPreDecSint16( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecSint16, A0, L); } bool ByteCodeEmitter::emitPreDecUint16( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecUint16, A0, L); } bool ByteCodeEmitter::emitPreDecSint32( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecSint32, A0, L); } bool ByteCodeEmitter::emitPreDecUint32( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecUint32, A0, L); } bool ByteCodeEmitter::emitPreDecSint64( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecSint64, A0, L); } bool ByteCodeEmitter::emitPreDecUint64( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecUint64, A0, L); } bool ByteCodeEmitter::emitPreDecIntAP( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecIntAP, A0, L); } bool ByteCodeEmitter::emitPreDecIntAPS( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecIntAPS, A0, L); } bool ByteCodeEmitter::emitPreDecBool( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecBool, A0, L); } bool ByteCodeEmitter::emitPreDecFixedPoint( bool A0, const SourceInfo &L) { return emitOp(OP_PreDecFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitPreDecSint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecUint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecSint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecUint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecSint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecUint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecSint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecUint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecIntAP( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecIntAPS( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecBool( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } bool EvalEmitter::emitPreDecFixedPoint( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreDec(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_PreIncSint8, OP_PreIncUint8, OP_PreIncSint16, OP_PreIncUint16, OP_PreIncSint32, OP_PreIncUint32, OP_PreIncSint64, OP_PreIncUint64, OP_PreIncIntAP, OP_PreIncIntAPS, OP_PreIncBool, OP_PreIncFixedPoint, #endif #ifdef GET_INTERP case OP_PreIncSint8: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncUint8: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncSint16: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncUint16: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncSint32: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncUint32: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncSint64: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncUint64: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncIntAP: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncIntAPS: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncBool: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } case OP_PreIncFixedPoint: { const auto V0 = ReadArg(S, PC); if (!PreInc(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_PreIncSint8: Text.Op = PrintName("PreIncSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncUint8: Text.Op = PrintName("PreIncUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncSint16: Text.Op = PrintName("PreIncSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncUint16: Text.Op = PrintName("PreIncUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncSint32: Text.Op = PrintName("PreIncSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncUint32: Text.Op = PrintName("PreIncUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncSint64: Text.Op = PrintName("PreIncSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncUint64: Text.Op = PrintName("PreIncUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncIntAP: Text.Op = PrintName("PreIncIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncIntAPS: Text.Op = PrintName("PreIncIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncBool: Text.Op = PrintName("PreIncBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_PreIncFixedPoint: Text.Op = PrintName("PreIncFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitPreIncSint8( bool , const SourceInfo &); bool emitPreIncUint8( bool , const SourceInfo &); bool emitPreIncSint16( bool , const SourceInfo &); bool emitPreIncUint16( bool , const SourceInfo &); bool emitPreIncSint32( bool , const SourceInfo &); bool emitPreIncUint32( bool , const SourceInfo &); bool emitPreIncSint64( bool , const SourceInfo &); bool emitPreIncUint64( bool , const SourceInfo &); bool emitPreIncIntAP( bool , const SourceInfo &); bool emitPreIncIntAPS( bool , const SourceInfo &); bool emitPreIncBool( bool , const SourceInfo &); bool emitPreIncFixedPoint( bool , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitPreInc(PrimType, bool, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitPreInc(PrimType T0, bool A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitPreIncSint8(A0, I); case PT_Uint8: return emitPreIncUint8(A0, I); case PT_Sint16: return emitPreIncSint16(A0, I); case PT_Uint16: return emitPreIncUint16(A0, I); case PT_Sint32: return emitPreIncSint32(A0, I); case PT_Uint32: return emitPreIncUint32(A0, I); case PT_Sint64: return emitPreIncSint64(A0, I); case PT_Uint64: return emitPreIncUint64(A0, I); case PT_IntAP: return emitPreIncIntAP(A0, I); case PT_IntAPS: return emitPreIncIntAPS(A0, I); case PT_Bool: return emitPreIncBool(A0, I); case PT_FixedPoint: return emitPreIncFixedPoint(A0, I); default: llvm_unreachable("invalid type: emitPreInc"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitPreIncSint8( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncSint8, A0, L); } bool ByteCodeEmitter::emitPreIncUint8( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncUint8, A0, L); } bool ByteCodeEmitter::emitPreIncSint16( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncSint16, A0, L); } bool ByteCodeEmitter::emitPreIncUint16( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncUint16, A0, L); } bool ByteCodeEmitter::emitPreIncSint32( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncSint32, A0, L); } bool ByteCodeEmitter::emitPreIncUint32( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncUint32, A0, L); } bool ByteCodeEmitter::emitPreIncSint64( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncSint64, A0, L); } bool ByteCodeEmitter::emitPreIncUint64( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncUint64, A0, L); } bool ByteCodeEmitter::emitPreIncIntAP( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncIntAP, A0, L); } bool ByteCodeEmitter::emitPreIncIntAPS( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncIntAPS, A0, L); } bool ByteCodeEmitter::emitPreIncBool( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncBool, A0, L); } bool ByteCodeEmitter::emitPreIncFixedPoint( bool A0, const SourceInfo &L) { return emitOp(OP_PreIncFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitPreIncSint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncUint8( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncSint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncUint16( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncSint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncUint32( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncSint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncUint64( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncIntAP( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncIntAPS( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncBool( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } bool EvalEmitter::emitPreIncFixedPoint( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PreInc(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_PtrPtrCast, #endif #ifdef GET_INTERP case OP_PtrPtrCast: { const auto V0 = ReadArg(S, PC); if (!PtrPtrCast(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_PtrPtrCast: Text.Op = PrintName("PtrPtrCast"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitPtrPtrCast( bool , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitPtrPtrCast( bool A0, const SourceInfo &L) { return emitOp(OP_PtrPtrCast, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitPtrPtrCast( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PtrPtrCast(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_PushCC, #endif #ifdef GET_INTERP case OP_PushCC: { const auto V0 = ReadArg(S, PC); if (!PushCC(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_PushCC: Text.Op = PrintName("PushCC"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitPushCC( bool , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitPushCC( bool A0, const SourceInfo &L) { return emitOp(OP_PushCC, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitPushCC( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return PushCC(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_RVOPtr, #endif #ifdef GET_INTERP case OP_RVOPtr: { if (!RVOPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_RVOPtr: Text.Op = PrintName("RVOPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitRVOPtr(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitRVOPtr(const SourceInfo &L) { return emitOp<>(OP_RVOPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitRVOPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return RVOPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_RemSint8, OP_RemUint8, OP_RemSint16, OP_RemUint16, OP_RemSint32, OP_RemUint32, OP_RemSint64, OP_RemUint64, OP_RemIntAP, OP_RemIntAPS, OP_RemFixedPoint, #endif #ifdef GET_INTERP case OP_RemSint8: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemUint8: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemSint16: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemUint16: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemSint32: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemUint32: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemSint64: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemUint64: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemIntAP: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemIntAPS: { if (!Rem(S, OpPC)) return false; continue; } case OP_RemFixedPoint: { if (!Rem(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_RemSint8: Text.Op = PrintName("RemSint8"); break; case OP_RemUint8: Text.Op = PrintName("RemUint8"); break; case OP_RemSint16: Text.Op = PrintName("RemSint16"); break; case OP_RemUint16: Text.Op = PrintName("RemUint16"); break; case OP_RemSint32: Text.Op = PrintName("RemSint32"); break; case OP_RemUint32: Text.Op = PrintName("RemUint32"); break; case OP_RemSint64: Text.Op = PrintName("RemSint64"); break; case OP_RemUint64: Text.Op = PrintName("RemUint64"); break; case OP_RemIntAP: Text.Op = PrintName("RemIntAP"); break; case OP_RemIntAPS: Text.Op = PrintName("RemIntAPS"); break; case OP_RemFixedPoint: Text.Op = PrintName("RemFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitRemSint8(const SourceInfo &); bool emitRemUint8(const SourceInfo &); bool emitRemSint16(const SourceInfo &); bool emitRemUint16(const SourceInfo &); bool emitRemSint32(const SourceInfo &); bool emitRemUint32(const SourceInfo &); bool emitRemSint64(const SourceInfo &); bool emitRemUint64(const SourceInfo &); bool emitRemIntAP(const SourceInfo &); bool emitRemIntAPS(const SourceInfo &); bool emitRemFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitRem(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitRem(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitRemSint8(I); case PT_Uint8: return emitRemUint8(I); case PT_Sint16: return emitRemSint16(I); case PT_Uint16: return emitRemUint16(I); case PT_Sint32: return emitRemSint32(I); case PT_Uint32: return emitRemUint32(I); case PT_Sint64: return emitRemSint64(I); case PT_Uint64: return emitRemUint64(I); case PT_IntAP: return emitRemIntAP(I); case PT_IntAPS: return emitRemIntAPS(I); case PT_FixedPoint: return emitRemFixedPoint(I); default: llvm_unreachable("invalid type: emitRem"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitRemSint8(const SourceInfo &L) { return emitOp<>(OP_RemSint8, L); } bool ByteCodeEmitter::emitRemUint8(const SourceInfo &L) { return emitOp<>(OP_RemUint8, L); } bool ByteCodeEmitter::emitRemSint16(const SourceInfo &L) { return emitOp<>(OP_RemSint16, L); } bool ByteCodeEmitter::emitRemUint16(const SourceInfo &L) { return emitOp<>(OP_RemUint16, L); } bool ByteCodeEmitter::emitRemSint32(const SourceInfo &L) { return emitOp<>(OP_RemSint32, L); } bool ByteCodeEmitter::emitRemUint32(const SourceInfo &L) { return emitOp<>(OP_RemUint32, L); } bool ByteCodeEmitter::emitRemSint64(const SourceInfo &L) { return emitOp<>(OP_RemSint64, L); } bool ByteCodeEmitter::emitRemUint64(const SourceInfo &L) { return emitOp<>(OP_RemUint64, L); } bool ByteCodeEmitter::emitRemIntAP(const SourceInfo &L) { return emitOp<>(OP_RemIntAP, L); } bool ByteCodeEmitter::emitRemIntAPS(const SourceInfo &L) { return emitOp<>(OP_RemIntAPS, L); } bool ByteCodeEmitter::emitRemFixedPoint(const SourceInfo &L) { return emitOp<>(OP_RemFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitRemSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } bool EvalEmitter::emitRemFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Rem(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_RetSint8, OP_RetUint8, OP_RetSint16, OP_RetUint16, OP_RetSint32, OP_RetUint32, OP_RetSint64, OP_RetUint64, OP_RetIntAP, OP_RetIntAPS, OP_RetBool, OP_RetFixedPoint, OP_RetPtr, OP_RetMemberPtr, OP_RetFloat, #endif #ifdef GET_INTERP case OP_RetSint8: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetUint8: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetSint16: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetUint16: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetSint32: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetUint32: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetSint64: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetUint64: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetIntAP: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetIntAPS: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetBool: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetFixedPoint: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetPtr: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetMemberPtr: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } case OP_RetFloat: { bool DoReturn = (S.Current == StartFrame); if (!Ret(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } #endif #ifdef GET_DISASM case OP_RetSint8: Text.Op = PrintName("RetSint8"); break; case OP_RetUint8: Text.Op = PrintName("RetUint8"); break; case OP_RetSint16: Text.Op = PrintName("RetSint16"); break; case OP_RetUint16: Text.Op = PrintName("RetUint16"); break; case OP_RetSint32: Text.Op = PrintName("RetSint32"); break; case OP_RetUint32: Text.Op = PrintName("RetUint32"); break; case OP_RetSint64: Text.Op = PrintName("RetSint64"); break; case OP_RetUint64: Text.Op = PrintName("RetUint64"); break; case OP_RetIntAP: Text.Op = PrintName("RetIntAP"); break; case OP_RetIntAPS: Text.Op = PrintName("RetIntAPS"); break; case OP_RetBool: Text.Op = PrintName("RetBool"); break; case OP_RetFixedPoint: Text.Op = PrintName("RetFixedPoint"); break; case OP_RetPtr: Text.Op = PrintName("RetPtr"); break; case OP_RetMemberPtr: Text.Op = PrintName("RetMemberPtr"); break; case OP_RetFloat: Text.Op = PrintName("RetFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitRetSint8(const SourceInfo &); bool emitRetUint8(const SourceInfo &); bool emitRetSint16(const SourceInfo &); bool emitRetUint16(const SourceInfo &); bool emitRetSint32(const SourceInfo &); bool emitRetUint32(const SourceInfo &); bool emitRetSint64(const SourceInfo &); bool emitRetUint64(const SourceInfo &); bool emitRetIntAP(const SourceInfo &); bool emitRetIntAPS(const SourceInfo &); bool emitRetBool(const SourceInfo &); bool emitRetFixedPoint(const SourceInfo &); bool emitRetPtr(const SourceInfo &); bool emitRetMemberPtr(const SourceInfo &); bool emitRetFloat(const SourceInfo &); #if defined(GET_EVAL_PROTO) template bool emitRet(const SourceInfo &); #endif #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitRet(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitRet(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: #ifdef GET_LINK_IMPL return emitRetSint8 #else return emitRet #endif (I); case PT_Uint8: #ifdef GET_LINK_IMPL return emitRetUint8 #else return emitRet #endif (I); case PT_Sint16: #ifdef GET_LINK_IMPL return emitRetSint16 #else return emitRet #endif (I); case PT_Uint16: #ifdef GET_LINK_IMPL return emitRetUint16 #else return emitRet #endif (I); case PT_Sint32: #ifdef GET_LINK_IMPL return emitRetSint32 #else return emitRet #endif (I); case PT_Uint32: #ifdef GET_LINK_IMPL return emitRetUint32 #else return emitRet #endif (I); case PT_Sint64: #ifdef GET_LINK_IMPL return emitRetSint64 #else return emitRet #endif (I); case PT_Uint64: #ifdef GET_LINK_IMPL return emitRetUint64 #else return emitRet #endif (I); case PT_IntAP: #ifdef GET_LINK_IMPL return emitRetIntAP #else return emitRet #endif (I); case PT_IntAPS: #ifdef GET_LINK_IMPL return emitRetIntAPS #else return emitRet #endif (I); case PT_Bool: #ifdef GET_LINK_IMPL return emitRetBool #else return emitRet #endif (I); case PT_FixedPoint: #ifdef GET_LINK_IMPL return emitRetFixedPoint #else return emitRet #endif (I); case PT_Ptr: #ifdef GET_LINK_IMPL return emitRetPtr #else return emitRet #endif (I); case PT_MemberPtr: #ifdef GET_LINK_IMPL return emitRetMemberPtr #else return emitRet #endif (I); case PT_Float: #ifdef GET_LINK_IMPL return emitRetFloat #else return emitRet #endif (I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitRetSint8(const SourceInfo &L) { return emitOp<>(OP_RetSint8, L); } bool ByteCodeEmitter::emitRetUint8(const SourceInfo &L) { return emitOp<>(OP_RetUint8, L); } bool ByteCodeEmitter::emitRetSint16(const SourceInfo &L) { return emitOp<>(OP_RetSint16, L); } bool ByteCodeEmitter::emitRetUint16(const SourceInfo &L) { return emitOp<>(OP_RetUint16, L); } bool ByteCodeEmitter::emitRetSint32(const SourceInfo &L) { return emitOp<>(OP_RetSint32, L); } bool ByteCodeEmitter::emitRetUint32(const SourceInfo &L) { return emitOp<>(OP_RetUint32, L); } bool ByteCodeEmitter::emitRetSint64(const SourceInfo &L) { return emitOp<>(OP_RetSint64, L); } bool ByteCodeEmitter::emitRetUint64(const SourceInfo &L) { return emitOp<>(OP_RetUint64, L); } bool ByteCodeEmitter::emitRetIntAP(const SourceInfo &L) { return emitOp<>(OP_RetIntAP, L); } bool ByteCodeEmitter::emitRetIntAPS(const SourceInfo &L) { return emitOp<>(OP_RetIntAPS, L); } bool ByteCodeEmitter::emitRetBool(const SourceInfo &L) { return emitOp<>(OP_RetBool, L); } bool ByteCodeEmitter::emitRetFixedPoint(const SourceInfo &L) { return emitOp<>(OP_RetFixedPoint, L); } bool ByteCodeEmitter::emitRetPtr(const SourceInfo &L) { return emitOp<>(OP_RetPtr, L); } bool ByteCodeEmitter::emitRetMemberPtr(const SourceInfo &L) { return emitOp<>(OP_RetMemberPtr, L); } bool ByteCodeEmitter::emitRetFloat(const SourceInfo &L) { return emitOp<>(OP_RetFloat, L); } #endif #ifdef GET_OPCODE_NAMES OP_RetValue, #endif #ifdef GET_INTERP case OP_RetValue: { bool DoReturn = (S.Current == StartFrame); if (!RetValue(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } #endif #ifdef GET_DISASM case OP_RetValue: Text.Op = PrintName("RetValue"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitRetValue(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitRetValue(const SourceInfo &L) { return emitOp<>(OP_RetValue, L); } #endif #ifdef GET_OPCODE_NAMES OP_RetVoid, #endif #ifdef GET_INTERP case OP_RetVoid: { bool DoReturn = (S.Current == StartFrame); if (!RetVoid(S, PC)) return false; if (!S.Current || S.Current->isRoot()) return true; if (DoReturn) return true; continue; } #endif #ifdef GET_DISASM case OP_RetVoid: Text.Op = PrintName("RetVoid"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitRetVoid(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitRetVoid(const SourceInfo &L) { return emitOp<>(OP_RetVoid, L); } #endif #ifdef GET_OPCODE_NAMES OP_SetFieldSint8, OP_SetFieldUint8, OP_SetFieldSint16, OP_SetFieldUint16, OP_SetFieldSint32, OP_SetFieldUint32, OP_SetFieldSint64, OP_SetFieldUint64, OP_SetFieldIntAP, OP_SetFieldIntAPS, OP_SetFieldBool, OP_SetFieldFixedPoint, OP_SetFieldPtr, OP_SetFieldMemberPtr, OP_SetFieldFloat, #endif #ifdef GET_INTERP case OP_SetFieldSint8: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldUint8: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldSint16: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldUint16: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldSint32: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldUint32: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldSint64: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldUint64: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldIntAP: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldIntAPS: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldBool: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldFixedPoint: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldPtr: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldMemberPtr: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } case OP_SetFieldFloat: { const auto V0 = ReadArg(S, PC); if (!SetField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_SetFieldSint8: Text.Op = PrintName("SetFieldSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldUint8: Text.Op = PrintName("SetFieldUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldSint16: Text.Op = PrintName("SetFieldSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldUint16: Text.Op = PrintName("SetFieldUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldSint32: Text.Op = PrintName("SetFieldSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldUint32: Text.Op = PrintName("SetFieldUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldSint64: Text.Op = PrintName("SetFieldSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldUint64: Text.Op = PrintName("SetFieldUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldIntAP: Text.Op = PrintName("SetFieldIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldIntAPS: Text.Op = PrintName("SetFieldIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldBool: Text.Op = PrintName("SetFieldBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldFixedPoint: Text.Op = PrintName("SetFieldFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldPtr: Text.Op = PrintName("SetFieldPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldMemberPtr: Text.Op = PrintName("SetFieldMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetFieldFloat: Text.Op = PrintName("SetFieldFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSetFieldSint8( uint32_t , const SourceInfo &); bool emitSetFieldUint8( uint32_t , const SourceInfo &); bool emitSetFieldSint16( uint32_t , const SourceInfo &); bool emitSetFieldUint16( uint32_t , const SourceInfo &); bool emitSetFieldSint32( uint32_t , const SourceInfo &); bool emitSetFieldUint32( uint32_t , const SourceInfo &); bool emitSetFieldSint64( uint32_t , const SourceInfo &); bool emitSetFieldUint64( uint32_t , const SourceInfo &); bool emitSetFieldIntAP( uint32_t , const SourceInfo &); bool emitSetFieldIntAPS( uint32_t , const SourceInfo &); bool emitSetFieldBool( uint32_t , const SourceInfo &); bool emitSetFieldFixedPoint( uint32_t , const SourceInfo &); bool emitSetFieldPtr( uint32_t , const SourceInfo &); bool emitSetFieldMemberPtr( uint32_t , const SourceInfo &); bool emitSetFieldFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitSetField(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitSetField(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitSetFieldSint8(A0, I); case PT_Uint8: return emitSetFieldUint8(A0, I); case PT_Sint16: return emitSetFieldSint16(A0, I); case PT_Uint16: return emitSetFieldUint16(A0, I); case PT_Sint32: return emitSetFieldSint32(A0, I); case PT_Uint32: return emitSetFieldUint32(A0, I); case PT_Sint64: return emitSetFieldSint64(A0, I); case PT_Uint64: return emitSetFieldUint64(A0, I); case PT_IntAP: return emitSetFieldIntAP(A0, I); case PT_IntAPS: return emitSetFieldIntAPS(A0, I); case PT_Bool: return emitSetFieldBool(A0, I); case PT_FixedPoint: return emitSetFieldFixedPoint(A0, I); case PT_Ptr: return emitSetFieldPtr(A0, I); case PT_MemberPtr: return emitSetFieldMemberPtr(A0, I); case PT_Float: return emitSetFieldFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSetFieldSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldSint8, A0, L); } bool ByteCodeEmitter::emitSetFieldUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldUint8, A0, L); } bool ByteCodeEmitter::emitSetFieldSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldSint16, A0, L); } bool ByteCodeEmitter::emitSetFieldUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldUint16, A0, L); } bool ByteCodeEmitter::emitSetFieldSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldSint32, A0, L); } bool ByteCodeEmitter::emitSetFieldUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldUint32, A0, L); } bool ByteCodeEmitter::emitSetFieldSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldSint64, A0, L); } bool ByteCodeEmitter::emitSetFieldUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldUint64, A0, L); } bool ByteCodeEmitter::emitSetFieldIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldIntAP, A0, L); } bool ByteCodeEmitter::emitSetFieldIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldIntAPS, A0, L); } bool ByteCodeEmitter::emitSetFieldBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldBool, A0, L); } bool ByteCodeEmitter::emitSetFieldFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldFixedPoint, A0, L); } bool ByteCodeEmitter::emitSetFieldPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldPtr, A0, L); } bool ByteCodeEmitter::emitSetFieldMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldMemberPtr, A0, L); } bool ByteCodeEmitter::emitSetFieldFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetFieldFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSetFieldSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } bool EvalEmitter::emitSetFieldFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_SetGlobalSint8, OP_SetGlobalUint8, OP_SetGlobalSint16, OP_SetGlobalUint16, OP_SetGlobalSint32, OP_SetGlobalUint32, OP_SetGlobalSint64, OP_SetGlobalUint64, OP_SetGlobalIntAP, OP_SetGlobalIntAPS, OP_SetGlobalBool, OP_SetGlobalFixedPoint, OP_SetGlobalPtr, OP_SetGlobalMemberPtr, OP_SetGlobalFloat, #endif #ifdef GET_INTERP case OP_SetGlobalSint8: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalUint8: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalSint16: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalUint16: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalSint32: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalUint32: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalSint64: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalUint64: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalIntAP: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalIntAPS: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalBool: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalFixedPoint: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalPtr: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalMemberPtr: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } case OP_SetGlobalFloat: { const auto V0 = ReadArg(S, PC); if (!SetGlobal(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_SetGlobalSint8: Text.Op = PrintName("SetGlobalSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalUint8: Text.Op = PrintName("SetGlobalUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalSint16: Text.Op = PrintName("SetGlobalSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalUint16: Text.Op = PrintName("SetGlobalUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalSint32: Text.Op = PrintName("SetGlobalSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalUint32: Text.Op = PrintName("SetGlobalUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalSint64: Text.Op = PrintName("SetGlobalSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalUint64: Text.Op = PrintName("SetGlobalUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalIntAP: Text.Op = PrintName("SetGlobalIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalIntAPS: Text.Op = PrintName("SetGlobalIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalBool: Text.Op = PrintName("SetGlobalBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalFixedPoint: Text.Op = PrintName("SetGlobalFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalPtr: Text.Op = PrintName("SetGlobalPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalMemberPtr: Text.Op = PrintName("SetGlobalMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetGlobalFloat: Text.Op = PrintName("SetGlobalFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSetGlobalSint8( uint32_t , const SourceInfo &); bool emitSetGlobalUint8( uint32_t , const SourceInfo &); bool emitSetGlobalSint16( uint32_t , const SourceInfo &); bool emitSetGlobalUint16( uint32_t , const SourceInfo &); bool emitSetGlobalSint32( uint32_t , const SourceInfo &); bool emitSetGlobalUint32( uint32_t , const SourceInfo &); bool emitSetGlobalSint64( uint32_t , const SourceInfo &); bool emitSetGlobalUint64( uint32_t , const SourceInfo &); bool emitSetGlobalIntAP( uint32_t , const SourceInfo &); bool emitSetGlobalIntAPS( uint32_t , const SourceInfo &); bool emitSetGlobalBool( uint32_t , const SourceInfo &); bool emitSetGlobalFixedPoint( uint32_t , const SourceInfo &); bool emitSetGlobalPtr( uint32_t , const SourceInfo &); bool emitSetGlobalMemberPtr( uint32_t , const SourceInfo &); bool emitSetGlobalFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitSetGlobal(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitSetGlobal(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitSetGlobalSint8(A0, I); case PT_Uint8: return emitSetGlobalUint8(A0, I); case PT_Sint16: return emitSetGlobalSint16(A0, I); case PT_Uint16: return emitSetGlobalUint16(A0, I); case PT_Sint32: return emitSetGlobalSint32(A0, I); case PT_Uint32: return emitSetGlobalUint32(A0, I); case PT_Sint64: return emitSetGlobalSint64(A0, I); case PT_Uint64: return emitSetGlobalUint64(A0, I); case PT_IntAP: return emitSetGlobalIntAP(A0, I); case PT_IntAPS: return emitSetGlobalIntAPS(A0, I); case PT_Bool: return emitSetGlobalBool(A0, I); case PT_FixedPoint: return emitSetGlobalFixedPoint(A0, I); case PT_Ptr: return emitSetGlobalPtr(A0, I); case PT_MemberPtr: return emitSetGlobalMemberPtr(A0, I); case PT_Float: return emitSetGlobalFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSetGlobalSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalSint8, A0, L); } bool ByteCodeEmitter::emitSetGlobalUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalUint8, A0, L); } bool ByteCodeEmitter::emitSetGlobalSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalSint16, A0, L); } bool ByteCodeEmitter::emitSetGlobalUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalUint16, A0, L); } bool ByteCodeEmitter::emitSetGlobalSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalSint32, A0, L); } bool ByteCodeEmitter::emitSetGlobalUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalUint32, A0, L); } bool ByteCodeEmitter::emitSetGlobalSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalSint64, A0, L); } bool ByteCodeEmitter::emitSetGlobalUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalUint64, A0, L); } bool ByteCodeEmitter::emitSetGlobalIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalIntAP, A0, L); } bool ByteCodeEmitter::emitSetGlobalIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalIntAPS, A0, L); } bool ByteCodeEmitter::emitSetGlobalBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalBool, A0, L); } bool ByteCodeEmitter::emitSetGlobalFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalFixedPoint, A0, L); } bool ByteCodeEmitter::emitSetGlobalPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalPtr, A0, L); } bool ByteCodeEmitter::emitSetGlobalMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalMemberPtr, A0, L); } bool ByteCodeEmitter::emitSetGlobalFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetGlobalFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSetGlobalSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } bool EvalEmitter::emitSetGlobalFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetGlobal(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_SetLocalSint8, OP_SetLocalUint8, OP_SetLocalSint16, OP_SetLocalUint16, OP_SetLocalSint32, OP_SetLocalUint32, OP_SetLocalSint64, OP_SetLocalUint64, OP_SetLocalIntAP, OP_SetLocalIntAPS, OP_SetLocalBool, OP_SetLocalFixedPoint, OP_SetLocalPtr, OP_SetLocalMemberPtr, OP_SetLocalFloat, #endif #ifdef GET_INTERP case OP_SetLocalSint8: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalUint8: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalSint16: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalUint16: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalSint32: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalUint32: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalSint64: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalUint64: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalIntAP: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalIntAPS: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalBool: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalFixedPoint: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalPtr: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalMemberPtr: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } case OP_SetLocalFloat: { const auto V0 = ReadArg(S, PC); if (!SetLocal(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_SetLocalSint8: Text.Op = PrintName("SetLocalSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalUint8: Text.Op = PrintName("SetLocalUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalSint16: Text.Op = PrintName("SetLocalSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalUint16: Text.Op = PrintName("SetLocalUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalSint32: Text.Op = PrintName("SetLocalSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalUint32: Text.Op = PrintName("SetLocalUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalSint64: Text.Op = PrintName("SetLocalSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalUint64: Text.Op = PrintName("SetLocalUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalIntAP: Text.Op = PrintName("SetLocalIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalIntAPS: Text.Op = PrintName("SetLocalIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalBool: Text.Op = PrintName("SetLocalBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalFixedPoint: Text.Op = PrintName("SetLocalFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalPtr: Text.Op = PrintName("SetLocalPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalMemberPtr: Text.Op = PrintName("SetLocalMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetLocalFloat: Text.Op = PrintName("SetLocalFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSetLocalSint8( uint32_t , const SourceInfo &); bool emitSetLocalUint8( uint32_t , const SourceInfo &); bool emitSetLocalSint16( uint32_t , const SourceInfo &); bool emitSetLocalUint16( uint32_t , const SourceInfo &); bool emitSetLocalSint32( uint32_t , const SourceInfo &); bool emitSetLocalUint32( uint32_t , const SourceInfo &); bool emitSetLocalSint64( uint32_t , const SourceInfo &); bool emitSetLocalUint64( uint32_t , const SourceInfo &); bool emitSetLocalIntAP( uint32_t , const SourceInfo &); bool emitSetLocalIntAPS( uint32_t , const SourceInfo &); bool emitSetLocalBool( uint32_t , const SourceInfo &); bool emitSetLocalFixedPoint( uint32_t , const SourceInfo &); bool emitSetLocalPtr( uint32_t , const SourceInfo &); bool emitSetLocalMemberPtr( uint32_t , const SourceInfo &); bool emitSetLocalFloat( uint32_t , const SourceInfo &); #if defined(GET_EVAL_PROTO) template bool emitSetLocal(uint32_t, const SourceInfo &); #endif #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitSetLocal(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitSetLocal(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: #ifdef GET_LINK_IMPL return emitSetLocalSint8 #else return emitSetLocal #endif (A0, I); case PT_Uint8: #ifdef GET_LINK_IMPL return emitSetLocalUint8 #else return emitSetLocal #endif (A0, I); case PT_Sint16: #ifdef GET_LINK_IMPL return emitSetLocalSint16 #else return emitSetLocal #endif (A0, I); case PT_Uint16: #ifdef GET_LINK_IMPL return emitSetLocalUint16 #else return emitSetLocal #endif (A0, I); case PT_Sint32: #ifdef GET_LINK_IMPL return emitSetLocalSint32 #else return emitSetLocal #endif (A0, I); case PT_Uint32: #ifdef GET_LINK_IMPL return emitSetLocalUint32 #else return emitSetLocal #endif (A0, I); case PT_Sint64: #ifdef GET_LINK_IMPL return emitSetLocalSint64 #else return emitSetLocal #endif (A0, I); case PT_Uint64: #ifdef GET_LINK_IMPL return emitSetLocalUint64 #else return emitSetLocal #endif (A0, I); case PT_IntAP: #ifdef GET_LINK_IMPL return emitSetLocalIntAP #else return emitSetLocal #endif (A0, I); case PT_IntAPS: #ifdef GET_LINK_IMPL return emitSetLocalIntAPS #else return emitSetLocal #endif (A0, I); case PT_Bool: #ifdef GET_LINK_IMPL return emitSetLocalBool #else return emitSetLocal #endif (A0, I); case PT_FixedPoint: #ifdef GET_LINK_IMPL return emitSetLocalFixedPoint #else return emitSetLocal #endif (A0, I); case PT_Ptr: #ifdef GET_LINK_IMPL return emitSetLocalPtr #else return emitSetLocal #endif (A0, I); case PT_MemberPtr: #ifdef GET_LINK_IMPL return emitSetLocalMemberPtr #else return emitSetLocal #endif (A0, I); case PT_Float: #ifdef GET_LINK_IMPL return emitSetLocalFloat #else return emitSetLocal #endif (A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSetLocalSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalSint8, A0, L); } bool ByteCodeEmitter::emitSetLocalUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalUint8, A0, L); } bool ByteCodeEmitter::emitSetLocalSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalSint16, A0, L); } bool ByteCodeEmitter::emitSetLocalUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalUint16, A0, L); } bool ByteCodeEmitter::emitSetLocalSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalSint32, A0, L); } bool ByteCodeEmitter::emitSetLocalUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalUint32, A0, L); } bool ByteCodeEmitter::emitSetLocalSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalSint64, A0, L); } bool ByteCodeEmitter::emitSetLocalUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalUint64, A0, L); } bool ByteCodeEmitter::emitSetLocalIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalIntAP, A0, L); } bool ByteCodeEmitter::emitSetLocalIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalIntAPS, A0, L); } bool ByteCodeEmitter::emitSetLocalBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalBool, A0, L); } bool ByteCodeEmitter::emitSetLocalFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalFixedPoint, A0, L); } bool ByteCodeEmitter::emitSetLocalPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalPtr, A0, L); } bool ByteCodeEmitter::emitSetLocalMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalMemberPtr, A0, L); } bool ByteCodeEmitter::emitSetLocalFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetLocalFloat, A0, L); } #endif #ifdef GET_OPCODE_NAMES OP_SetParamSint8, OP_SetParamUint8, OP_SetParamSint16, OP_SetParamUint16, OP_SetParamSint32, OP_SetParamUint32, OP_SetParamSint64, OP_SetParamUint64, OP_SetParamIntAP, OP_SetParamIntAPS, OP_SetParamBool, OP_SetParamFixedPoint, OP_SetParamPtr, OP_SetParamMemberPtr, OP_SetParamFloat, #endif #ifdef GET_INTERP case OP_SetParamSint8: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamUint8: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamSint16: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamUint16: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamSint32: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamUint32: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamSint64: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamUint64: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamIntAP: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamIntAPS: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamBool: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamFixedPoint: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamPtr: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamMemberPtr: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } case OP_SetParamFloat: { const auto V0 = ReadArg(S, PC); if (!SetParam(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_SetParamSint8: Text.Op = PrintName("SetParamSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamUint8: Text.Op = PrintName("SetParamUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamSint16: Text.Op = PrintName("SetParamSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamUint16: Text.Op = PrintName("SetParamUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamSint32: Text.Op = PrintName("SetParamSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamUint32: Text.Op = PrintName("SetParamUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamSint64: Text.Op = PrintName("SetParamSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamUint64: Text.Op = PrintName("SetParamUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamIntAP: Text.Op = PrintName("SetParamIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamIntAPS: Text.Op = PrintName("SetParamIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamBool: Text.Op = PrintName("SetParamBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamFixedPoint: Text.Op = PrintName("SetParamFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamPtr: Text.Op = PrintName("SetParamPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamMemberPtr: Text.Op = PrintName("SetParamMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetParamFloat: Text.Op = PrintName("SetParamFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSetParamSint8( uint32_t , const SourceInfo &); bool emitSetParamUint8( uint32_t , const SourceInfo &); bool emitSetParamSint16( uint32_t , const SourceInfo &); bool emitSetParamUint16( uint32_t , const SourceInfo &); bool emitSetParamSint32( uint32_t , const SourceInfo &); bool emitSetParamUint32( uint32_t , const SourceInfo &); bool emitSetParamSint64( uint32_t , const SourceInfo &); bool emitSetParamUint64( uint32_t , const SourceInfo &); bool emitSetParamIntAP( uint32_t , const SourceInfo &); bool emitSetParamIntAPS( uint32_t , const SourceInfo &); bool emitSetParamBool( uint32_t , const SourceInfo &); bool emitSetParamFixedPoint( uint32_t , const SourceInfo &); bool emitSetParamPtr( uint32_t , const SourceInfo &); bool emitSetParamMemberPtr( uint32_t , const SourceInfo &); bool emitSetParamFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitSetParam(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitSetParam(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitSetParamSint8(A0, I); case PT_Uint8: return emitSetParamUint8(A0, I); case PT_Sint16: return emitSetParamSint16(A0, I); case PT_Uint16: return emitSetParamUint16(A0, I); case PT_Sint32: return emitSetParamSint32(A0, I); case PT_Uint32: return emitSetParamUint32(A0, I); case PT_Sint64: return emitSetParamSint64(A0, I); case PT_Uint64: return emitSetParamUint64(A0, I); case PT_IntAP: return emitSetParamIntAP(A0, I); case PT_IntAPS: return emitSetParamIntAPS(A0, I); case PT_Bool: return emitSetParamBool(A0, I); case PT_FixedPoint: return emitSetParamFixedPoint(A0, I); case PT_Ptr: return emitSetParamPtr(A0, I); case PT_MemberPtr: return emitSetParamMemberPtr(A0, I); case PT_Float: return emitSetParamFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSetParamSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamSint8, A0, L); } bool ByteCodeEmitter::emitSetParamUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamUint8, A0, L); } bool ByteCodeEmitter::emitSetParamSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamSint16, A0, L); } bool ByteCodeEmitter::emitSetParamUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamUint16, A0, L); } bool ByteCodeEmitter::emitSetParamSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamSint32, A0, L); } bool ByteCodeEmitter::emitSetParamUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamUint32, A0, L); } bool ByteCodeEmitter::emitSetParamSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamSint64, A0, L); } bool ByteCodeEmitter::emitSetParamUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamUint64, A0, L); } bool ByteCodeEmitter::emitSetParamIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamIntAP, A0, L); } bool ByteCodeEmitter::emitSetParamIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamIntAPS, A0, L); } bool ByteCodeEmitter::emitSetParamBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamBool, A0, L); } bool ByteCodeEmitter::emitSetParamFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamFixedPoint, A0, L); } bool ByteCodeEmitter::emitSetParamPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamPtr, A0, L); } bool ByteCodeEmitter::emitSetParamMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamMemberPtr, A0, L); } bool ByteCodeEmitter::emitSetParamFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetParamFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSetParamSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } bool EvalEmitter::emitSetParamFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetParam(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_SetThisFieldSint8, OP_SetThisFieldUint8, OP_SetThisFieldSint16, OP_SetThisFieldUint16, OP_SetThisFieldSint32, OP_SetThisFieldUint32, OP_SetThisFieldSint64, OP_SetThisFieldUint64, OP_SetThisFieldIntAP, OP_SetThisFieldIntAPS, OP_SetThisFieldBool, OP_SetThisFieldFixedPoint, OP_SetThisFieldPtr, OP_SetThisFieldMemberPtr, OP_SetThisFieldFloat, #endif #ifdef GET_INTERP case OP_SetThisFieldSint8: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldUint8: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldSint16: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldUint16: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldSint32: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldUint32: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldSint64: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldUint64: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldIntAP: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldIntAPS: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldBool: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldFixedPoint: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldPtr: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldMemberPtr: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } case OP_SetThisFieldFloat: { const auto V0 = ReadArg(S, PC); if (!SetThisField(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_SetThisFieldSint8: Text.Op = PrintName("SetThisFieldSint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldUint8: Text.Op = PrintName("SetThisFieldUint8"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldSint16: Text.Op = PrintName("SetThisFieldSint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldUint16: Text.Op = PrintName("SetThisFieldUint16"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldSint32: Text.Op = PrintName("SetThisFieldSint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldUint32: Text.Op = PrintName("SetThisFieldUint32"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldSint64: Text.Op = PrintName("SetThisFieldSint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldUint64: Text.Op = PrintName("SetThisFieldUint64"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldIntAP: Text.Op = PrintName("SetThisFieldIntAP"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldIntAPS: Text.Op = PrintName("SetThisFieldIntAPS"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldBool: Text.Op = PrintName("SetThisFieldBool"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldFixedPoint: Text.Op = PrintName("SetThisFieldFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldPtr: Text.Op = PrintName("SetThisFieldPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldMemberPtr: Text.Op = PrintName("SetThisFieldMemberPtr"); Text.Args.push_back(printArg(P, PC)); break; case OP_SetThisFieldFloat: Text.Op = PrintName("SetThisFieldFloat"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSetThisFieldSint8( uint32_t , const SourceInfo &); bool emitSetThisFieldUint8( uint32_t , const SourceInfo &); bool emitSetThisFieldSint16( uint32_t , const SourceInfo &); bool emitSetThisFieldUint16( uint32_t , const SourceInfo &); bool emitSetThisFieldSint32( uint32_t , const SourceInfo &); bool emitSetThisFieldUint32( uint32_t , const SourceInfo &); bool emitSetThisFieldSint64( uint32_t , const SourceInfo &); bool emitSetThisFieldUint64( uint32_t , const SourceInfo &); bool emitSetThisFieldIntAP( uint32_t , const SourceInfo &); bool emitSetThisFieldIntAPS( uint32_t , const SourceInfo &); bool emitSetThisFieldBool( uint32_t , const SourceInfo &); bool emitSetThisFieldFixedPoint( uint32_t , const SourceInfo &); bool emitSetThisFieldPtr( uint32_t , const SourceInfo &); bool emitSetThisFieldMemberPtr( uint32_t , const SourceInfo &); bool emitSetThisFieldFloat( uint32_t , const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitSetThisField(PrimType, uint32_t, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitSetThisField(PrimType T0, uint32_t A0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitSetThisFieldSint8(A0, I); case PT_Uint8: return emitSetThisFieldUint8(A0, I); case PT_Sint16: return emitSetThisFieldSint16(A0, I); case PT_Uint16: return emitSetThisFieldUint16(A0, I); case PT_Sint32: return emitSetThisFieldSint32(A0, I); case PT_Uint32: return emitSetThisFieldUint32(A0, I); case PT_Sint64: return emitSetThisFieldSint64(A0, I); case PT_Uint64: return emitSetThisFieldUint64(A0, I); case PT_IntAP: return emitSetThisFieldIntAP(A0, I); case PT_IntAPS: return emitSetThisFieldIntAPS(A0, I); case PT_Bool: return emitSetThisFieldBool(A0, I); case PT_FixedPoint: return emitSetThisFieldFixedPoint(A0, I); case PT_Ptr: return emitSetThisFieldPtr(A0, I); case PT_MemberPtr: return emitSetThisFieldMemberPtr(A0, I); case PT_Float: return emitSetThisFieldFloat(A0, I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSetThisFieldSint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldSint8, A0, L); } bool ByteCodeEmitter::emitSetThisFieldUint8( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldUint8, A0, L); } bool ByteCodeEmitter::emitSetThisFieldSint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldSint16, A0, L); } bool ByteCodeEmitter::emitSetThisFieldUint16( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldUint16, A0, L); } bool ByteCodeEmitter::emitSetThisFieldSint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldSint32, A0, L); } bool ByteCodeEmitter::emitSetThisFieldUint32( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldUint32, A0, L); } bool ByteCodeEmitter::emitSetThisFieldSint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldSint64, A0, L); } bool ByteCodeEmitter::emitSetThisFieldUint64( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldUint64, A0, L); } bool ByteCodeEmitter::emitSetThisFieldIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldIntAP, A0, L); } bool ByteCodeEmitter::emitSetThisFieldIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldIntAPS, A0, L); } bool ByteCodeEmitter::emitSetThisFieldBool( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldBool, A0, L); } bool ByteCodeEmitter::emitSetThisFieldFixedPoint( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldFixedPoint, A0, L); } bool ByteCodeEmitter::emitSetThisFieldPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldPtr, A0, L); } bool ByteCodeEmitter::emitSetThisFieldMemberPtr( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldMemberPtr, A0, L); } bool ByteCodeEmitter::emitSetThisFieldFloat( uint32_t A0, const SourceInfo &L) { return emitOp(OP_SetThisFieldFloat, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSetThisFieldSint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldUint8( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldSint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldUint16( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldSint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldUint32( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldSint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldUint64( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldBool( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldFixedPoint( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldMemberPtr( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } bool EvalEmitter::emitSetThisFieldFloat( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SetThisField(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ShiftFixedPoint, #endif #ifdef GET_INTERP case OP_ShiftFixedPoint: { const auto V0 = ReadArg(S, PC); if (!ShiftFixedPoint(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ShiftFixedPoint: Text.Op = PrintName("ShiftFixedPoint"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitShiftFixedPoint( bool , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitShiftFixedPoint( bool A0, const SourceInfo &L) { return emitOp(OP_ShiftFixedPoint, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitShiftFixedPoint( bool A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ShiftFixedPoint(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ShlSint8Sint8, OP_ShlSint8Uint8, OP_ShlSint8Sint16, OP_ShlSint8Uint16, OP_ShlSint8Sint32, OP_ShlSint8Uint32, OP_ShlSint8Sint64, OP_ShlSint8Uint64, OP_ShlSint8IntAP, OP_ShlSint8IntAPS, OP_ShlUint8Sint8, OP_ShlUint8Uint8, OP_ShlUint8Sint16, OP_ShlUint8Uint16, OP_ShlUint8Sint32, OP_ShlUint8Uint32, OP_ShlUint8Sint64, OP_ShlUint8Uint64, OP_ShlUint8IntAP, OP_ShlUint8IntAPS, OP_ShlSint16Sint8, OP_ShlSint16Uint8, OP_ShlSint16Sint16, OP_ShlSint16Uint16, OP_ShlSint16Sint32, OP_ShlSint16Uint32, OP_ShlSint16Sint64, OP_ShlSint16Uint64, OP_ShlSint16IntAP, OP_ShlSint16IntAPS, OP_ShlUint16Sint8, OP_ShlUint16Uint8, OP_ShlUint16Sint16, OP_ShlUint16Uint16, OP_ShlUint16Sint32, OP_ShlUint16Uint32, OP_ShlUint16Sint64, OP_ShlUint16Uint64, OP_ShlUint16IntAP, OP_ShlUint16IntAPS, OP_ShlSint32Sint8, OP_ShlSint32Uint8, OP_ShlSint32Sint16, OP_ShlSint32Uint16, OP_ShlSint32Sint32, OP_ShlSint32Uint32, OP_ShlSint32Sint64, OP_ShlSint32Uint64, OP_ShlSint32IntAP, OP_ShlSint32IntAPS, OP_ShlUint32Sint8, OP_ShlUint32Uint8, OP_ShlUint32Sint16, OP_ShlUint32Uint16, OP_ShlUint32Sint32, OP_ShlUint32Uint32, OP_ShlUint32Sint64, OP_ShlUint32Uint64, OP_ShlUint32IntAP, OP_ShlUint32IntAPS, OP_ShlSint64Sint8, OP_ShlSint64Uint8, OP_ShlSint64Sint16, OP_ShlSint64Uint16, OP_ShlSint64Sint32, OP_ShlSint64Uint32, OP_ShlSint64Sint64, OP_ShlSint64Uint64, OP_ShlSint64IntAP, OP_ShlSint64IntAPS, OP_ShlUint64Sint8, OP_ShlUint64Uint8, OP_ShlUint64Sint16, OP_ShlUint64Uint16, OP_ShlUint64Sint32, OP_ShlUint64Uint32, OP_ShlUint64Sint64, OP_ShlUint64Uint64, OP_ShlUint64IntAP, OP_ShlUint64IntAPS, OP_ShlIntAPSint8, OP_ShlIntAPUint8, OP_ShlIntAPSint16, OP_ShlIntAPUint16, OP_ShlIntAPSint32, OP_ShlIntAPUint32, OP_ShlIntAPSint64, OP_ShlIntAPUint64, OP_ShlIntAPIntAP, OP_ShlIntAPIntAPS, OP_ShlIntAPSSint8, OP_ShlIntAPSUint8, OP_ShlIntAPSSint16, OP_ShlIntAPSUint16, OP_ShlIntAPSSint32, OP_ShlIntAPSUint32, OP_ShlIntAPSSint64, OP_ShlIntAPSUint64, OP_ShlIntAPSIntAP, OP_ShlIntAPSIntAPS, #endif #ifdef GET_INTERP case OP_ShlSint8Sint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint8Uint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint8Sint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint8Uint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint8Sint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint8Uint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint8Sint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint8Uint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint8IntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint8IntAPS: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8Sint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8Uint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8Sint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8Uint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8Sint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8Uint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8Sint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8Uint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8IntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint8IntAPS: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16Sint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16Uint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16Sint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16Uint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16Sint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16Uint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16Sint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16Uint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16IntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint16IntAPS: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16Sint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16Uint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16Sint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16Uint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16Sint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16Uint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16Sint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16Uint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16IntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint16IntAPS: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32Sint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32Uint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32Sint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32Uint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32Sint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32Uint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32Sint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32Uint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32IntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint32IntAPS: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32Sint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32Uint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32Sint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32Uint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32Sint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32Uint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32Sint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32Uint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32IntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint32IntAPS: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64Sint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64Uint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64Sint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64Uint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64Sint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64Uint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64Sint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64Uint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64IntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlSint64IntAPS: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64Sint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64Uint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64Sint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64Uint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64Sint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64Uint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64Sint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64Uint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64IntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlUint64IntAPS: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPUint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPUint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPUint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPUint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPIntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPIntAPS: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSSint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSUint8: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSSint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSUint16: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSSint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSUint32: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSSint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSUint64: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSIntAP: { if (!Shl(S, OpPC)) return false; continue; } case OP_ShlIntAPSIntAPS: { if (!Shl(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_ShlSint8Sint8: Text.Op = PrintName("ShlSint8Sint8"); break; case OP_ShlSint8Uint8: Text.Op = PrintName("ShlSint8Uint8"); break; case OP_ShlSint8Sint16: Text.Op = PrintName("ShlSint8Sint16"); break; case OP_ShlSint8Uint16: Text.Op = PrintName("ShlSint8Uint16"); break; case OP_ShlSint8Sint32: Text.Op = PrintName("ShlSint8Sint32"); break; case OP_ShlSint8Uint32: Text.Op = PrintName("ShlSint8Uint32"); break; case OP_ShlSint8Sint64: Text.Op = PrintName("ShlSint8Sint64"); break; case OP_ShlSint8Uint64: Text.Op = PrintName("ShlSint8Uint64"); break; case OP_ShlSint8IntAP: Text.Op = PrintName("ShlSint8IntAP"); break; case OP_ShlSint8IntAPS: Text.Op = PrintName("ShlSint8IntAPS"); break; case OP_ShlUint8Sint8: Text.Op = PrintName("ShlUint8Sint8"); break; case OP_ShlUint8Uint8: Text.Op = PrintName("ShlUint8Uint8"); break; case OP_ShlUint8Sint16: Text.Op = PrintName("ShlUint8Sint16"); break; case OP_ShlUint8Uint16: Text.Op = PrintName("ShlUint8Uint16"); break; case OP_ShlUint8Sint32: Text.Op = PrintName("ShlUint8Sint32"); break; case OP_ShlUint8Uint32: Text.Op = PrintName("ShlUint8Uint32"); break; case OP_ShlUint8Sint64: Text.Op = PrintName("ShlUint8Sint64"); break; case OP_ShlUint8Uint64: Text.Op = PrintName("ShlUint8Uint64"); break; case OP_ShlUint8IntAP: Text.Op = PrintName("ShlUint8IntAP"); break; case OP_ShlUint8IntAPS: Text.Op = PrintName("ShlUint8IntAPS"); break; case OP_ShlSint16Sint8: Text.Op = PrintName("ShlSint16Sint8"); break; case OP_ShlSint16Uint8: Text.Op = PrintName("ShlSint16Uint8"); break; case OP_ShlSint16Sint16: Text.Op = PrintName("ShlSint16Sint16"); break; case OP_ShlSint16Uint16: Text.Op = PrintName("ShlSint16Uint16"); break; case OP_ShlSint16Sint32: Text.Op = PrintName("ShlSint16Sint32"); break; case OP_ShlSint16Uint32: Text.Op = PrintName("ShlSint16Uint32"); break; case OP_ShlSint16Sint64: Text.Op = PrintName("ShlSint16Sint64"); break; case OP_ShlSint16Uint64: Text.Op = PrintName("ShlSint16Uint64"); break; case OP_ShlSint16IntAP: Text.Op = PrintName("ShlSint16IntAP"); break; case OP_ShlSint16IntAPS: Text.Op = PrintName("ShlSint16IntAPS"); break; case OP_ShlUint16Sint8: Text.Op = PrintName("ShlUint16Sint8"); break; case OP_ShlUint16Uint8: Text.Op = PrintName("ShlUint16Uint8"); break; case OP_ShlUint16Sint16: Text.Op = PrintName("ShlUint16Sint16"); break; case OP_ShlUint16Uint16: Text.Op = PrintName("ShlUint16Uint16"); break; case OP_ShlUint16Sint32: Text.Op = PrintName("ShlUint16Sint32"); break; case OP_ShlUint16Uint32: Text.Op = PrintName("ShlUint16Uint32"); break; case OP_ShlUint16Sint64: Text.Op = PrintName("ShlUint16Sint64"); break; case OP_ShlUint16Uint64: Text.Op = PrintName("ShlUint16Uint64"); break; case OP_ShlUint16IntAP: Text.Op = PrintName("ShlUint16IntAP"); break; case OP_ShlUint16IntAPS: Text.Op = PrintName("ShlUint16IntAPS"); break; case OP_ShlSint32Sint8: Text.Op = PrintName("ShlSint32Sint8"); break; case OP_ShlSint32Uint8: Text.Op = PrintName("ShlSint32Uint8"); break; case OP_ShlSint32Sint16: Text.Op = PrintName("ShlSint32Sint16"); break; case OP_ShlSint32Uint16: Text.Op = PrintName("ShlSint32Uint16"); break; case OP_ShlSint32Sint32: Text.Op = PrintName("ShlSint32Sint32"); break; case OP_ShlSint32Uint32: Text.Op = PrintName("ShlSint32Uint32"); break; case OP_ShlSint32Sint64: Text.Op = PrintName("ShlSint32Sint64"); break; case OP_ShlSint32Uint64: Text.Op = PrintName("ShlSint32Uint64"); break; case OP_ShlSint32IntAP: Text.Op = PrintName("ShlSint32IntAP"); break; case OP_ShlSint32IntAPS: Text.Op = PrintName("ShlSint32IntAPS"); break; case OP_ShlUint32Sint8: Text.Op = PrintName("ShlUint32Sint8"); break; case OP_ShlUint32Uint8: Text.Op = PrintName("ShlUint32Uint8"); break; case OP_ShlUint32Sint16: Text.Op = PrintName("ShlUint32Sint16"); break; case OP_ShlUint32Uint16: Text.Op = PrintName("ShlUint32Uint16"); break; case OP_ShlUint32Sint32: Text.Op = PrintName("ShlUint32Sint32"); break; case OP_ShlUint32Uint32: Text.Op = PrintName("ShlUint32Uint32"); break; case OP_ShlUint32Sint64: Text.Op = PrintName("ShlUint32Sint64"); break; case OP_ShlUint32Uint64: Text.Op = PrintName("ShlUint32Uint64"); break; case OP_ShlUint32IntAP: Text.Op = PrintName("ShlUint32IntAP"); break; case OP_ShlUint32IntAPS: Text.Op = PrintName("ShlUint32IntAPS"); break; case OP_ShlSint64Sint8: Text.Op = PrintName("ShlSint64Sint8"); break; case OP_ShlSint64Uint8: Text.Op = PrintName("ShlSint64Uint8"); break; case OP_ShlSint64Sint16: Text.Op = PrintName("ShlSint64Sint16"); break; case OP_ShlSint64Uint16: Text.Op = PrintName("ShlSint64Uint16"); break; case OP_ShlSint64Sint32: Text.Op = PrintName("ShlSint64Sint32"); break; case OP_ShlSint64Uint32: Text.Op = PrintName("ShlSint64Uint32"); break; case OP_ShlSint64Sint64: Text.Op = PrintName("ShlSint64Sint64"); break; case OP_ShlSint64Uint64: Text.Op = PrintName("ShlSint64Uint64"); break; case OP_ShlSint64IntAP: Text.Op = PrintName("ShlSint64IntAP"); break; case OP_ShlSint64IntAPS: Text.Op = PrintName("ShlSint64IntAPS"); break; case OP_ShlUint64Sint8: Text.Op = PrintName("ShlUint64Sint8"); break; case OP_ShlUint64Uint8: Text.Op = PrintName("ShlUint64Uint8"); break; case OP_ShlUint64Sint16: Text.Op = PrintName("ShlUint64Sint16"); break; case OP_ShlUint64Uint16: Text.Op = PrintName("ShlUint64Uint16"); break; case OP_ShlUint64Sint32: Text.Op = PrintName("ShlUint64Sint32"); break; case OP_ShlUint64Uint32: Text.Op = PrintName("ShlUint64Uint32"); break; case OP_ShlUint64Sint64: Text.Op = PrintName("ShlUint64Sint64"); break; case OP_ShlUint64Uint64: Text.Op = PrintName("ShlUint64Uint64"); break; case OP_ShlUint64IntAP: Text.Op = PrintName("ShlUint64IntAP"); break; case OP_ShlUint64IntAPS: Text.Op = PrintName("ShlUint64IntAPS"); break; case OP_ShlIntAPSint8: Text.Op = PrintName("ShlIntAPSint8"); break; case OP_ShlIntAPUint8: Text.Op = PrintName("ShlIntAPUint8"); break; case OP_ShlIntAPSint16: Text.Op = PrintName("ShlIntAPSint16"); break; case OP_ShlIntAPUint16: Text.Op = PrintName("ShlIntAPUint16"); break; case OP_ShlIntAPSint32: Text.Op = PrintName("ShlIntAPSint32"); break; case OP_ShlIntAPUint32: Text.Op = PrintName("ShlIntAPUint32"); break; case OP_ShlIntAPSint64: Text.Op = PrintName("ShlIntAPSint64"); break; case OP_ShlIntAPUint64: Text.Op = PrintName("ShlIntAPUint64"); break; case OP_ShlIntAPIntAP: Text.Op = PrintName("ShlIntAPIntAP"); break; case OP_ShlIntAPIntAPS: Text.Op = PrintName("ShlIntAPIntAPS"); break; case OP_ShlIntAPSSint8: Text.Op = PrintName("ShlIntAPSSint8"); break; case OP_ShlIntAPSUint8: Text.Op = PrintName("ShlIntAPSUint8"); break; case OP_ShlIntAPSSint16: Text.Op = PrintName("ShlIntAPSSint16"); break; case OP_ShlIntAPSUint16: Text.Op = PrintName("ShlIntAPSUint16"); break; case OP_ShlIntAPSSint32: Text.Op = PrintName("ShlIntAPSSint32"); break; case OP_ShlIntAPSUint32: Text.Op = PrintName("ShlIntAPSUint32"); break; case OP_ShlIntAPSSint64: Text.Op = PrintName("ShlIntAPSSint64"); break; case OP_ShlIntAPSUint64: Text.Op = PrintName("ShlIntAPSUint64"); break; case OP_ShlIntAPSIntAP: Text.Op = PrintName("ShlIntAPSIntAP"); break; case OP_ShlIntAPSIntAPS: Text.Op = PrintName("ShlIntAPSIntAPS"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitShlSint8Sint8(const SourceInfo &); bool emitShlSint8Uint8(const SourceInfo &); bool emitShlSint8Sint16(const SourceInfo &); bool emitShlSint8Uint16(const SourceInfo &); bool emitShlSint8Sint32(const SourceInfo &); bool emitShlSint8Uint32(const SourceInfo &); bool emitShlSint8Sint64(const SourceInfo &); bool emitShlSint8Uint64(const SourceInfo &); bool emitShlSint8IntAP(const SourceInfo &); bool emitShlSint8IntAPS(const SourceInfo &); bool emitShlUint8Sint8(const SourceInfo &); bool emitShlUint8Uint8(const SourceInfo &); bool emitShlUint8Sint16(const SourceInfo &); bool emitShlUint8Uint16(const SourceInfo &); bool emitShlUint8Sint32(const SourceInfo &); bool emitShlUint8Uint32(const SourceInfo &); bool emitShlUint8Sint64(const SourceInfo &); bool emitShlUint8Uint64(const SourceInfo &); bool emitShlUint8IntAP(const SourceInfo &); bool emitShlUint8IntAPS(const SourceInfo &); bool emitShlSint16Sint8(const SourceInfo &); bool emitShlSint16Uint8(const SourceInfo &); bool emitShlSint16Sint16(const SourceInfo &); bool emitShlSint16Uint16(const SourceInfo &); bool emitShlSint16Sint32(const SourceInfo &); bool emitShlSint16Uint32(const SourceInfo &); bool emitShlSint16Sint64(const SourceInfo &); bool emitShlSint16Uint64(const SourceInfo &); bool emitShlSint16IntAP(const SourceInfo &); bool emitShlSint16IntAPS(const SourceInfo &); bool emitShlUint16Sint8(const SourceInfo &); bool emitShlUint16Uint8(const SourceInfo &); bool emitShlUint16Sint16(const SourceInfo &); bool emitShlUint16Uint16(const SourceInfo &); bool emitShlUint16Sint32(const SourceInfo &); bool emitShlUint16Uint32(const SourceInfo &); bool emitShlUint16Sint64(const SourceInfo &); bool emitShlUint16Uint64(const SourceInfo &); bool emitShlUint16IntAP(const SourceInfo &); bool emitShlUint16IntAPS(const SourceInfo &); bool emitShlSint32Sint8(const SourceInfo &); bool emitShlSint32Uint8(const SourceInfo &); bool emitShlSint32Sint16(const SourceInfo &); bool emitShlSint32Uint16(const SourceInfo &); bool emitShlSint32Sint32(const SourceInfo &); bool emitShlSint32Uint32(const SourceInfo &); bool emitShlSint32Sint64(const SourceInfo &); bool emitShlSint32Uint64(const SourceInfo &); bool emitShlSint32IntAP(const SourceInfo &); bool emitShlSint32IntAPS(const SourceInfo &); bool emitShlUint32Sint8(const SourceInfo &); bool emitShlUint32Uint8(const SourceInfo &); bool emitShlUint32Sint16(const SourceInfo &); bool emitShlUint32Uint16(const SourceInfo &); bool emitShlUint32Sint32(const SourceInfo &); bool emitShlUint32Uint32(const SourceInfo &); bool emitShlUint32Sint64(const SourceInfo &); bool emitShlUint32Uint64(const SourceInfo &); bool emitShlUint32IntAP(const SourceInfo &); bool emitShlUint32IntAPS(const SourceInfo &); bool emitShlSint64Sint8(const SourceInfo &); bool emitShlSint64Uint8(const SourceInfo &); bool emitShlSint64Sint16(const SourceInfo &); bool emitShlSint64Uint16(const SourceInfo &); bool emitShlSint64Sint32(const SourceInfo &); bool emitShlSint64Uint32(const SourceInfo &); bool emitShlSint64Sint64(const SourceInfo &); bool emitShlSint64Uint64(const SourceInfo &); bool emitShlSint64IntAP(const SourceInfo &); bool emitShlSint64IntAPS(const SourceInfo &); bool emitShlUint64Sint8(const SourceInfo &); bool emitShlUint64Uint8(const SourceInfo &); bool emitShlUint64Sint16(const SourceInfo &); bool emitShlUint64Uint16(const SourceInfo &); bool emitShlUint64Sint32(const SourceInfo &); bool emitShlUint64Uint32(const SourceInfo &); bool emitShlUint64Sint64(const SourceInfo &); bool emitShlUint64Uint64(const SourceInfo &); bool emitShlUint64IntAP(const SourceInfo &); bool emitShlUint64IntAPS(const SourceInfo &); bool emitShlIntAPSint8(const SourceInfo &); bool emitShlIntAPUint8(const SourceInfo &); bool emitShlIntAPSint16(const SourceInfo &); bool emitShlIntAPUint16(const SourceInfo &); bool emitShlIntAPSint32(const SourceInfo &); bool emitShlIntAPUint32(const SourceInfo &); bool emitShlIntAPSint64(const SourceInfo &); bool emitShlIntAPUint64(const SourceInfo &); bool emitShlIntAPIntAP(const SourceInfo &); bool emitShlIntAPIntAPS(const SourceInfo &); bool emitShlIntAPSSint8(const SourceInfo &); bool emitShlIntAPSUint8(const SourceInfo &); bool emitShlIntAPSSint16(const SourceInfo &); bool emitShlIntAPSUint16(const SourceInfo &); bool emitShlIntAPSSint32(const SourceInfo &); bool emitShlIntAPSUint32(const SourceInfo &); bool emitShlIntAPSSint64(const SourceInfo &); bool emitShlIntAPSUint64(const SourceInfo &); bool emitShlIntAPSIntAP(const SourceInfo &); bool emitShlIntAPSIntAPS(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitShl(PrimType, PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitShl(PrimType T0, PrimType T1, const SourceInfo &I) { switch (T0) { case PT_Sint8: switch (T1) { case PT_Sint8: return emitShlSint8Sint8(I); case PT_Uint8: return emitShlSint8Uint8(I); case PT_Sint16: return emitShlSint8Sint16(I); case PT_Uint16: return emitShlSint8Uint16(I); case PT_Sint32: return emitShlSint8Sint32(I); case PT_Uint32: return emitShlSint8Uint32(I); case PT_Sint64: return emitShlSint8Sint64(I); case PT_Uint64: return emitShlSint8Uint64(I); case PT_IntAP: return emitShlSint8IntAP(I); case PT_IntAPS: return emitShlSint8IntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); case PT_Uint8: switch (T1) { case PT_Sint8: return emitShlUint8Sint8(I); case PT_Uint8: return emitShlUint8Uint8(I); case PT_Sint16: return emitShlUint8Sint16(I); case PT_Uint16: return emitShlUint8Uint16(I); case PT_Sint32: return emitShlUint8Sint32(I); case PT_Uint32: return emitShlUint8Uint32(I); case PT_Sint64: return emitShlUint8Sint64(I); case PT_Uint64: return emitShlUint8Uint64(I); case PT_IntAP: return emitShlUint8IntAP(I); case PT_IntAPS: return emitShlUint8IntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); case PT_Sint16: switch (T1) { case PT_Sint8: return emitShlSint16Sint8(I); case PT_Uint8: return emitShlSint16Uint8(I); case PT_Sint16: return emitShlSint16Sint16(I); case PT_Uint16: return emitShlSint16Uint16(I); case PT_Sint32: return emitShlSint16Sint32(I); case PT_Uint32: return emitShlSint16Uint32(I); case PT_Sint64: return emitShlSint16Sint64(I); case PT_Uint64: return emitShlSint16Uint64(I); case PT_IntAP: return emitShlSint16IntAP(I); case PT_IntAPS: return emitShlSint16IntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); case PT_Uint16: switch (T1) { case PT_Sint8: return emitShlUint16Sint8(I); case PT_Uint8: return emitShlUint16Uint8(I); case PT_Sint16: return emitShlUint16Sint16(I); case PT_Uint16: return emitShlUint16Uint16(I); case PT_Sint32: return emitShlUint16Sint32(I); case PT_Uint32: return emitShlUint16Uint32(I); case PT_Sint64: return emitShlUint16Sint64(I); case PT_Uint64: return emitShlUint16Uint64(I); case PT_IntAP: return emitShlUint16IntAP(I); case PT_IntAPS: return emitShlUint16IntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); case PT_Sint32: switch (T1) { case PT_Sint8: return emitShlSint32Sint8(I); case PT_Uint8: return emitShlSint32Uint8(I); case PT_Sint16: return emitShlSint32Sint16(I); case PT_Uint16: return emitShlSint32Uint16(I); case PT_Sint32: return emitShlSint32Sint32(I); case PT_Uint32: return emitShlSint32Uint32(I); case PT_Sint64: return emitShlSint32Sint64(I); case PT_Uint64: return emitShlSint32Uint64(I); case PT_IntAP: return emitShlSint32IntAP(I); case PT_IntAPS: return emitShlSint32IntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); case PT_Uint32: switch (T1) { case PT_Sint8: return emitShlUint32Sint8(I); case PT_Uint8: return emitShlUint32Uint8(I); case PT_Sint16: return emitShlUint32Sint16(I); case PT_Uint16: return emitShlUint32Uint16(I); case PT_Sint32: return emitShlUint32Sint32(I); case PT_Uint32: return emitShlUint32Uint32(I); case PT_Sint64: return emitShlUint32Sint64(I); case PT_Uint64: return emitShlUint32Uint64(I); case PT_IntAP: return emitShlUint32IntAP(I); case PT_IntAPS: return emitShlUint32IntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); case PT_Sint64: switch (T1) { case PT_Sint8: return emitShlSint64Sint8(I); case PT_Uint8: return emitShlSint64Uint8(I); case PT_Sint16: return emitShlSint64Sint16(I); case PT_Uint16: return emitShlSint64Uint16(I); case PT_Sint32: return emitShlSint64Sint32(I); case PT_Uint32: return emitShlSint64Uint32(I); case PT_Sint64: return emitShlSint64Sint64(I); case PT_Uint64: return emitShlSint64Uint64(I); case PT_IntAP: return emitShlSint64IntAP(I); case PT_IntAPS: return emitShlSint64IntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); case PT_Uint64: switch (T1) { case PT_Sint8: return emitShlUint64Sint8(I); case PT_Uint8: return emitShlUint64Uint8(I); case PT_Sint16: return emitShlUint64Sint16(I); case PT_Uint16: return emitShlUint64Uint16(I); case PT_Sint32: return emitShlUint64Sint32(I); case PT_Uint32: return emitShlUint64Uint32(I); case PT_Sint64: return emitShlUint64Sint64(I); case PT_Uint64: return emitShlUint64Uint64(I); case PT_IntAP: return emitShlUint64IntAP(I); case PT_IntAPS: return emitShlUint64IntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); case PT_IntAP: switch (T1) { case PT_Sint8: return emitShlIntAPSint8(I); case PT_Uint8: return emitShlIntAPUint8(I); case PT_Sint16: return emitShlIntAPSint16(I); case PT_Uint16: return emitShlIntAPUint16(I); case PT_Sint32: return emitShlIntAPSint32(I); case PT_Uint32: return emitShlIntAPUint32(I); case PT_Sint64: return emitShlIntAPSint64(I); case PT_Uint64: return emitShlIntAPUint64(I); case PT_IntAP: return emitShlIntAPIntAP(I); case PT_IntAPS: return emitShlIntAPIntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); case PT_IntAPS: switch (T1) { case PT_Sint8: return emitShlIntAPSSint8(I); case PT_Uint8: return emitShlIntAPSUint8(I); case PT_Sint16: return emitShlIntAPSSint16(I); case PT_Uint16: return emitShlIntAPSUint16(I); case PT_Sint32: return emitShlIntAPSSint32(I); case PT_Uint32: return emitShlIntAPSUint32(I); case PT_Sint64: return emitShlIntAPSSint64(I); case PT_Uint64: return emitShlIntAPSUint64(I); case PT_IntAP: return emitShlIntAPSIntAP(I); case PT_IntAPS: return emitShlIntAPSIntAPS(I); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); default: llvm_unreachable("invalid type: emitShl"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitShlSint8Sint8(const SourceInfo &L) { return emitOp<>(OP_ShlSint8Sint8, L); } bool ByteCodeEmitter::emitShlSint8Uint8(const SourceInfo &L) { return emitOp<>(OP_ShlSint8Uint8, L); } bool ByteCodeEmitter::emitShlSint8Sint16(const SourceInfo &L) { return emitOp<>(OP_ShlSint8Sint16, L); } bool ByteCodeEmitter::emitShlSint8Uint16(const SourceInfo &L) { return emitOp<>(OP_ShlSint8Uint16, L); } bool ByteCodeEmitter::emitShlSint8Sint32(const SourceInfo &L) { return emitOp<>(OP_ShlSint8Sint32, L); } bool ByteCodeEmitter::emitShlSint8Uint32(const SourceInfo &L) { return emitOp<>(OP_ShlSint8Uint32, L); } bool ByteCodeEmitter::emitShlSint8Sint64(const SourceInfo &L) { return emitOp<>(OP_ShlSint8Sint64, L); } bool ByteCodeEmitter::emitShlSint8Uint64(const SourceInfo &L) { return emitOp<>(OP_ShlSint8Uint64, L); } bool ByteCodeEmitter::emitShlSint8IntAP(const SourceInfo &L) { return emitOp<>(OP_ShlSint8IntAP, L); } bool ByteCodeEmitter::emitShlSint8IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlSint8IntAPS, L); } bool ByteCodeEmitter::emitShlUint8Sint8(const SourceInfo &L) { return emitOp<>(OP_ShlUint8Sint8, L); } bool ByteCodeEmitter::emitShlUint8Uint8(const SourceInfo &L) { return emitOp<>(OP_ShlUint8Uint8, L); } bool ByteCodeEmitter::emitShlUint8Sint16(const SourceInfo &L) { return emitOp<>(OP_ShlUint8Sint16, L); } bool ByteCodeEmitter::emitShlUint8Uint16(const SourceInfo &L) { return emitOp<>(OP_ShlUint8Uint16, L); } bool ByteCodeEmitter::emitShlUint8Sint32(const SourceInfo &L) { return emitOp<>(OP_ShlUint8Sint32, L); } bool ByteCodeEmitter::emitShlUint8Uint32(const SourceInfo &L) { return emitOp<>(OP_ShlUint8Uint32, L); } bool ByteCodeEmitter::emitShlUint8Sint64(const SourceInfo &L) { return emitOp<>(OP_ShlUint8Sint64, L); } bool ByteCodeEmitter::emitShlUint8Uint64(const SourceInfo &L) { return emitOp<>(OP_ShlUint8Uint64, L); } bool ByteCodeEmitter::emitShlUint8IntAP(const SourceInfo &L) { return emitOp<>(OP_ShlUint8IntAP, L); } bool ByteCodeEmitter::emitShlUint8IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlUint8IntAPS, L); } bool ByteCodeEmitter::emitShlSint16Sint8(const SourceInfo &L) { return emitOp<>(OP_ShlSint16Sint8, L); } bool ByteCodeEmitter::emitShlSint16Uint8(const SourceInfo &L) { return emitOp<>(OP_ShlSint16Uint8, L); } bool ByteCodeEmitter::emitShlSint16Sint16(const SourceInfo &L) { return emitOp<>(OP_ShlSint16Sint16, L); } bool ByteCodeEmitter::emitShlSint16Uint16(const SourceInfo &L) { return emitOp<>(OP_ShlSint16Uint16, L); } bool ByteCodeEmitter::emitShlSint16Sint32(const SourceInfo &L) { return emitOp<>(OP_ShlSint16Sint32, L); } bool ByteCodeEmitter::emitShlSint16Uint32(const SourceInfo &L) { return emitOp<>(OP_ShlSint16Uint32, L); } bool ByteCodeEmitter::emitShlSint16Sint64(const SourceInfo &L) { return emitOp<>(OP_ShlSint16Sint64, L); } bool ByteCodeEmitter::emitShlSint16Uint64(const SourceInfo &L) { return emitOp<>(OP_ShlSint16Uint64, L); } bool ByteCodeEmitter::emitShlSint16IntAP(const SourceInfo &L) { return emitOp<>(OP_ShlSint16IntAP, L); } bool ByteCodeEmitter::emitShlSint16IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlSint16IntAPS, L); } bool ByteCodeEmitter::emitShlUint16Sint8(const SourceInfo &L) { return emitOp<>(OP_ShlUint16Sint8, L); } bool ByteCodeEmitter::emitShlUint16Uint8(const SourceInfo &L) { return emitOp<>(OP_ShlUint16Uint8, L); } bool ByteCodeEmitter::emitShlUint16Sint16(const SourceInfo &L) { return emitOp<>(OP_ShlUint16Sint16, L); } bool ByteCodeEmitter::emitShlUint16Uint16(const SourceInfo &L) { return emitOp<>(OP_ShlUint16Uint16, L); } bool ByteCodeEmitter::emitShlUint16Sint32(const SourceInfo &L) { return emitOp<>(OP_ShlUint16Sint32, L); } bool ByteCodeEmitter::emitShlUint16Uint32(const SourceInfo &L) { return emitOp<>(OP_ShlUint16Uint32, L); } bool ByteCodeEmitter::emitShlUint16Sint64(const SourceInfo &L) { return emitOp<>(OP_ShlUint16Sint64, L); } bool ByteCodeEmitter::emitShlUint16Uint64(const SourceInfo &L) { return emitOp<>(OP_ShlUint16Uint64, L); } bool ByteCodeEmitter::emitShlUint16IntAP(const SourceInfo &L) { return emitOp<>(OP_ShlUint16IntAP, L); } bool ByteCodeEmitter::emitShlUint16IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlUint16IntAPS, L); } bool ByteCodeEmitter::emitShlSint32Sint8(const SourceInfo &L) { return emitOp<>(OP_ShlSint32Sint8, L); } bool ByteCodeEmitter::emitShlSint32Uint8(const SourceInfo &L) { return emitOp<>(OP_ShlSint32Uint8, L); } bool ByteCodeEmitter::emitShlSint32Sint16(const SourceInfo &L) { return emitOp<>(OP_ShlSint32Sint16, L); } bool ByteCodeEmitter::emitShlSint32Uint16(const SourceInfo &L) { return emitOp<>(OP_ShlSint32Uint16, L); } bool ByteCodeEmitter::emitShlSint32Sint32(const SourceInfo &L) { return emitOp<>(OP_ShlSint32Sint32, L); } bool ByteCodeEmitter::emitShlSint32Uint32(const SourceInfo &L) { return emitOp<>(OP_ShlSint32Uint32, L); } bool ByteCodeEmitter::emitShlSint32Sint64(const SourceInfo &L) { return emitOp<>(OP_ShlSint32Sint64, L); } bool ByteCodeEmitter::emitShlSint32Uint64(const SourceInfo &L) { return emitOp<>(OP_ShlSint32Uint64, L); } bool ByteCodeEmitter::emitShlSint32IntAP(const SourceInfo &L) { return emitOp<>(OP_ShlSint32IntAP, L); } bool ByteCodeEmitter::emitShlSint32IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlSint32IntAPS, L); } bool ByteCodeEmitter::emitShlUint32Sint8(const SourceInfo &L) { return emitOp<>(OP_ShlUint32Sint8, L); } bool ByteCodeEmitter::emitShlUint32Uint8(const SourceInfo &L) { return emitOp<>(OP_ShlUint32Uint8, L); } bool ByteCodeEmitter::emitShlUint32Sint16(const SourceInfo &L) { return emitOp<>(OP_ShlUint32Sint16, L); } bool ByteCodeEmitter::emitShlUint32Uint16(const SourceInfo &L) { return emitOp<>(OP_ShlUint32Uint16, L); } bool ByteCodeEmitter::emitShlUint32Sint32(const SourceInfo &L) { return emitOp<>(OP_ShlUint32Sint32, L); } bool ByteCodeEmitter::emitShlUint32Uint32(const SourceInfo &L) { return emitOp<>(OP_ShlUint32Uint32, L); } bool ByteCodeEmitter::emitShlUint32Sint64(const SourceInfo &L) { return emitOp<>(OP_ShlUint32Sint64, L); } bool ByteCodeEmitter::emitShlUint32Uint64(const SourceInfo &L) { return emitOp<>(OP_ShlUint32Uint64, L); } bool ByteCodeEmitter::emitShlUint32IntAP(const SourceInfo &L) { return emitOp<>(OP_ShlUint32IntAP, L); } bool ByteCodeEmitter::emitShlUint32IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlUint32IntAPS, L); } bool ByteCodeEmitter::emitShlSint64Sint8(const SourceInfo &L) { return emitOp<>(OP_ShlSint64Sint8, L); } bool ByteCodeEmitter::emitShlSint64Uint8(const SourceInfo &L) { return emitOp<>(OP_ShlSint64Uint8, L); } bool ByteCodeEmitter::emitShlSint64Sint16(const SourceInfo &L) { return emitOp<>(OP_ShlSint64Sint16, L); } bool ByteCodeEmitter::emitShlSint64Uint16(const SourceInfo &L) { return emitOp<>(OP_ShlSint64Uint16, L); } bool ByteCodeEmitter::emitShlSint64Sint32(const SourceInfo &L) { return emitOp<>(OP_ShlSint64Sint32, L); } bool ByteCodeEmitter::emitShlSint64Uint32(const SourceInfo &L) { return emitOp<>(OP_ShlSint64Uint32, L); } bool ByteCodeEmitter::emitShlSint64Sint64(const SourceInfo &L) { return emitOp<>(OP_ShlSint64Sint64, L); } bool ByteCodeEmitter::emitShlSint64Uint64(const SourceInfo &L) { return emitOp<>(OP_ShlSint64Uint64, L); } bool ByteCodeEmitter::emitShlSint64IntAP(const SourceInfo &L) { return emitOp<>(OP_ShlSint64IntAP, L); } bool ByteCodeEmitter::emitShlSint64IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlSint64IntAPS, L); } bool ByteCodeEmitter::emitShlUint64Sint8(const SourceInfo &L) { return emitOp<>(OP_ShlUint64Sint8, L); } bool ByteCodeEmitter::emitShlUint64Uint8(const SourceInfo &L) { return emitOp<>(OP_ShlUint64Uint8, L); } bool ByteCodeEmitter::emitShlUint64Sint16(const SourceInfo &L) { return emitOp<>(OP_ShlUint64Sint16, L); } bool ByteCodeEmitter::emitShlUint64Uint16(const SourceInfo &L) { return emitOp<>(OP_ShlUint64Uint16, L); } bool ByteCodeEmitter::emitShlUint64Sint32(const SourceInfo &L) { return emitOp<>(OP_ShlUint64Sint32, L); } bool ByteCodeEmitter::emitShlUint64Uint32(const SourceInfo &L) { return emitOp<>(OP_ShlUint64Uint32, L); } bool ByteCodeEmitter::emitShlUint64Sint64(const SourceInfo &L) { return emitOp<>(OP_ShlUint64Sint64, L); } bool ByteCodeEmitter::emitShlUint64Uint64(const SourceInfo &L) { return emitOp<>(OP_ShlUint64Uint64, L); } bool ByteCodeEmitter::emitShlUint64IntAP(const SourceInfo &L) { return emitOp<>(OP_ShlUint64IntAP, L); } bool ByteCodeEmitter::emitShlUint64IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlUint64IntAPS, L); } bool ByteCodeEmitter::emitShlIntAPSint8(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSint8, L); } bool ByteCodeEmitter::emitShlIntAPUint8(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPUint8, L); } bool ByteCodeEmitter::emitShlIntAPSint16(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSint16, L); } bool ByteCodeEmitter::emitShlIntAPUint16(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPUint16, L); } bool ByteCodeEmitter::emitShlIntAPSint32(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSint32, L); } bool ByteCodeEmitter::emitShlIntAPUint32(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPUint32, L); } bool ByteCodeEmitter::emitShlIntAPSint64(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSint64, L); } bool ByteCodeEmitter::emitShlIntAPUint64(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPUint64, L); } bool ByteCodeEmitter::emitShlIntAPIntAP(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPIntAP, L); } bool ByteCodeEmitter::emitShlIntAPIntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPIntAPS, L); } bool ByteCodeEmitter::emitShlIntAPSSint8(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSSint8, L); } bool ByteCodeEmitter::emitShlIntAPSUint8(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSUint8, L); } bool ByteCodeEmitter::emitShlIntAPSSint16(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSSint16, L); } bool ByteCodeEmitter::emitShlIntAPSUint16(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSUint16, L); } bool ByteCodeEmitter::emitShlIntAPSSint32(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSSint32, L); } bool ByteCodeEmitter::emitShlIntAPSUint32(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSUint32, L); } bool ByteCodeEmitter::emitShlIntAPSSint64(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSSint64, L); } bool ByteCodeEmitter::emitShlIntAPSUint64(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSUint64, L); } bool ByteCodeEmitter::emitShlIntAPSIntAP(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSIntAP, L); } bool ByteCodeEmitter::emitShlIntAPSIntAPS(const SourceInfo &L) { return emitOp<>(OP_ShlIntAPSIntAPS, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitShlSint8Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint8Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint8Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint8Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint8Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint8Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint8Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint8Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint8IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint8IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint8IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint16IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint16IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint32IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint32IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlSint64IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlUint64IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } bool EvalEmitter::emitShlIntAPSIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shl(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_ShrSint8Sint8, OP_ShrSint8Uint8, OP_ShrSint8Sint16, OP_ShrSint8Uint16, OP_ShrSint8Sint32, OP_ShrSint8Uint32, OP_ShrSint8Sint64, OP_ShrSint8Uint64, OP_ShrSint8IntAP, OP_ShrSint8IntAPS, OP_ShrUint8Sint8, OP_ShrUint8Uint8, OP_ShrUint8Sint16, OP_ShrUint8Uint16, OP_ShrUint8Sint32, OP_ShrUint8Uint32, OP_ShrUint8Sint64, OP_ShrUint8Uint64, OP_ShrUint8IntAP, OP_ShrUint8IntAPS, OP_ShrSint16Sint8, OP_ShrSint16Uint8, OP_ShrSint16Sint16, OP_ShrSint16Uint16, OP_ShrSint16Sint32, OP_ShrSint16Uint32, OP_ShrSint16Sint64, OP_ShrSint16Uint64, OP_ShrSint16IntAP, OP_ShrSint16IntAPS, OP_ShrUint16Sint8, OP_ShrUint16Uint8, OP_ShrUint16Sint16, OP_ShrUint16Uint16, OP_ShrUint16Sint32, OP_ShrUint16Uint32, OP_ShrUint16Sint64, OP_ShrUint16Uint64, OP_ShrUint16IntAP, OP_ShrUint16IntAPS, OP_ShrSint32Sint8, OP_ShrSint32Uint8, OP_ShrSint32Sint16, OP_ShrSint32Uint16, OP_ShrSint32Sint32, OP_ShrSint32Uint32, OP_ShrSint32Sint64, OP_ShrSint32Uint64, OP_ShrSint32IntAP, OP_ShrSint32IntAPS, OP_ShrUint32Sint8, OP_ShrUint32Uint8, OP_ShrUint32Sint16, OP_ShrUint32Uint16, OP_ShrUint32Sint32, OP_ShrUint32Uint32, OP_ShrUint32Sint64, OP_ShrUint32Uint64, OP_ShrUint32IntAP, OP_ShrUint32IntAPS, OP_ShrSint64Sint8, OP_ShrSint64Uint8, OP_ShrSint64Sint16, OP_ShrSint64Uint16, OP_ShrSint64Sint32, OP_ShrSint64Uint32, OP_ShrSint64Sint64, OP_ShrSint64Uint64, OP_ShrSint64IntAP, OP_ShrSint64IntAPS, OP_ShrUint64Sint8, OP_ShrUint64Uint8, OP_ShrUint64Sint16, OP_ShrUint64Uint16, OP_ShrUint64Sint32, OP_ShrUint64Uint32, OP_ShrUint64Sint64, OP_ShrUint64Uint64, OP_ShrUint64IntAP, OP_ShrUint64IntAPS, OP_ShrIntAPSint8, OP_ShrIntAPUint8, OP_ShrIntAPSint16, OP_ShrIntAPUint16, OP_ShrIntAPSint32, OP_ShrIntAPUint32, OP_ShrIntAPSint64, OP_ShrIntAPUint64, OP_ShrIntAPIntAP, OP_ShrIntAPIntAPS, OP_ShrIntAPSSint8, OP_ShrIntAPSUint8, OP_ShrIntAPSSint16, OP_ShrIntAPSUint16, OP_ShrIntAPSSint32, OP_ShrIntAPSUint32, OP_ShrIntAPSSint64, OP_ShrIntAPSUint64, OP_ShrIntAPSIntAP, OP_ShrIntAPSIntAPS, #endif #ifdef GET_INTERP case OP_ShrSint8Sint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint8Uint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint8Sint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint8Uint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint8Sint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint8Uint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint8Sint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint8Uint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint8IntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint8IntAPS: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8Sint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8Uint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8Sint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8Uint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8Sint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8Uint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8Sint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8Uint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8IntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint8IntAPS: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16Sint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16Uint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16Sint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16Uint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16Sint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16Uint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16Sint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16Uint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16IntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint16IntAPS: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16Sint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16Uint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16Sint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16Uint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16Sint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16Uint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16Sint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16Uint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16IntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint16IntAPS: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32Sint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32Uint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32Sint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32Uint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32Sint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32Uint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32Sint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32Uint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32IntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint32IntAPS: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32Sint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32Uint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32Sint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32Uint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32Sint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32Uint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32Sint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32Uint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32IntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint32IntAPS: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64Sint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64Uint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64Sint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64Uint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64Sint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64Uint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64Sint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64Uint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64IntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrSint64IntAPS: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64Sint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64Uint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64Sint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64Uint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64Sint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64Uint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64Sint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64Uint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64IntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrUint64IntAPS: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPUint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPUint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPUint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPUint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPIntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPIntAPS: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSSint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSUint8: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSSint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSUint16: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSSint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSUint32: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSSint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSUint64: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSIntAP: { if (!Shr(S, OpPC)) return false; continue; } case OP_ShrIntAPSIntAPS: { if (!Shr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_ShrSint8Sint8: Text.Op = PrintName("ShrSint8Sint8"); break; case OP_ShrSint8Uint8: Text.Op = PrintName("ShrSint8Uint8"); break; case OP_ShrSint8Sint16: Text.Op = PrintName("ShrSint8Sint16"); break; case OP_ShrSint8Uint16: Text.Op = PrintName("ShrSint8Uint16"); break; case OP_ShrSint8Sint32: Text.Op = PrintName("ShrSint8Sint32"); break; case OP_ShrSint8Uint32: Text.Op = PrintName("ShrSint8Uint32"); break; case OP_ShrSint8Sint64: Text.Op = PrintName("ShrSint8Sint64"); break; case OP_ShrSint8Uint64: Text.Op = PrintName("ShrSint8Uint64"); break; case OP_ShrSint8IntAP: Text.Op = PrintName("ShrSint8IntAP"); break; case OP_ShrSint8IntAPS: Text.Op = PrintName("ShrSint8IntAPS"); break; case OP_ShrUint8Sint8: Text.Op = PrintName("ShrUint8Sint8"); break; case OP_ShrUint8Uint8: Text.Op = PrintName("ShrUint8Uint8"); break; case OP_ShrUint8Sint16: Text.Op = PrintName("ShrUint8Sint16"); break; case OP_ShrUint8Uint16: Text.Op = PrintName("ShrUint8Uint16"); break; case OP_ShrUint8Sint32: Text.Op = PrintName("ShrUint8Sint32"); break; case OP_ShrUint8Uint32: Text.Op = PrintName("ShrUint8Uint32"); break; case OP_ShrUint8Sint64: Text.Op = PrintName("ShrUint8Sint64"); break; case OP_ShrUint8Uint64: Text.Op = PrintName("ShrUint8Uint64"); break; case OP_ShrUint8IntAP: Text.Op = PrintName("ShrUint8IntAP"); break; case OP_ShrUint8IntAPS: Text.Op = PrintName("ShrUint8IntAPS"); break; case OP_ShrSint16Sint8: Text.Op = PrintName("ShrSint16Sint8"); break; case OP_ShrSint16Uint8: Text.Op = PrintName("ShrSint16Uint8"); break; case OP_ShrSint16Sint16: Text.Op = PrintName("ShrSint16Sint16"); break; case OP_ShrSint16Uint16: Text.Op = PrintName("ShrSint16Uint16"); break; case OP_ShrSint16Sint32: Text.Op = PrintName("ShrSint16Sint32"); break; case OP_ShrSint16Uint32: Text.Op = PrintName("ShrSint16Uint32"); break; case OP_ShrSint16Sint64: Text.Op = PrintName("ShrSint16Sint64"); break; case OP_ShrSint16Uint64: Text.Op = PrintName("ShrSint16Uint64"); break; case OP_ShrSint16IntAP: Text.Op = PrintName("ShrSint16IntAP"); break; case OP_ShrSint16IntAPS: Text.Op = PrintName("ShrSint16IntAPS"); break; case OP_ShrUint16Sint8: Text.Op = PrintName("ShrUint16Sint8"); break; case OP_ShrUint16Uint8: Text.Op = PrintName("ShrUint16Uint8"); break; case OP_ShrUint16Sint16: Text.Op = PrintName("ShrUint16Sint16"); break; case OP_ShrUint16Uint16: Text.Op = PrintName("ShrUint16Uint16"); break; case OP_ShrUint16Sint32: Text.Op = PrintName("ShrUint16Sint32"); break; case OP_ShrUint16Uint32: Text.Op = PrintName("ShrUint16Uint32"); break; case OP_ShrUint16Sint64: Text.Op = PrintName("ShrUint16Sint64"); break; case OP_ShrUint16Uint64: Text.Op = PrintName("ShrUint16Uint64"); break; case OP_ShrUint16IntAP: Text.Op = PrintName("ShrUint16IntAP"); break; case OP_ShrUint16IntAPS: Text.Op = PrintName("ShrUint16IntAPS"); break; case OP_ShrSint32Sint8: Text.Op = PrintName("ShrSint32Sint8"); break; case OP_ShrSint32Uint8: Text.Op = PrintName("ShrSint32Uint8"); break; case OP_ShrSint32Sint16: Text.Op = PrintName("ShrSint32Sint16"); break; case OP_ShrSint32Uint16: Text.Op = PrintName("ShrSint32Uint16"); break; case OP_ShrSint32Sint32: Text.Op = PrintName("ShrSint32Sint32"); break; case OP_ShrSint32Uint32: Text.Op = PrintName("ShrSint32Uint32"); break; case OP_ShrSint32Sint64: Text.Op = PrintName("ShrSint32Sint64"); break; case OP_ShrSint32Uint64: Text.Op = PrintName("ShrSint32Uint64"); break; case OP_ShrSint32IntAP: Text.Op = PrintName("ShrSint32IntAP"); break; case OP_ShrSint32IntAPS: Text.Op = PrintName("ShrSint32IntAPS"); break; case OP_ShrUint32Sint8: Text.Op = PrintName("ShrUint32Sint8"); break; case OP_ShrUint32Uint8: Text.Op = PrintName("ShrUint32Uint8"); break; case OP_ShrUint32Sint16: Text.Op = PrintName("ShrUint32Sint16"); break; case OP_ShrUint32Uint16: Text.Op = PrintName("ShrUint32Uint16"); break; case OP_ShrUint32Sint32: Text.Op = PrintName("ShrUint32Sint32"); break; case OP_ShrUint32Uint32: Text.Op = PrintName("ShrUint32Uint32"); break; case OP_ShrUint32Sint64: Text.Op = PrintName("ShrUint32Sint64"); break; case OP_ShrUint32Uint64: Text.Op = PrintName("ShrUint32Uint64"); break; case OP_ShrUint32IntAP: Text.Op = PrintName("ShrUint32IntAP"); break; case OP_ShrUint32IntAPS: Text.Op = PrintName("ShrUint32IntAPS"); break; case OP_ShrSint64Sint8: Text.Op = PrintName("ShrSint64Sint8"); break; case OP_ShrSint64Uint8: Text.Op = PrintName("ShrSint64Uint8"); break; case OP_ShrSint64Sint16: Text.Op = PrintName("ShrSint64Sint16"); break; case OP_ShrSint64Uint16: Text.Op = PrintName("ShrSint64Uint16"); break; case OP_ShrSint64Sint32: Text.Op = PrintName("ShrSint64Sint32"); break; case OP_ShrSint64Uint32: Text.Op = PrintName("ShrSint64Uint32"); break; case OP_ShrSint64Sint64: Text.Op = PrintName("ShrSint64Sint64"); break; case OP_ShrSint64Uint64: Text.Op = PrintName("ShrSint64Uint64"); break; case OP_ShrSint64IntAP: Text.Op = PrintName("ShrSint64IntAP"); break; case OP_ShrSint64IntAPS: Text.Op = PrintName("ShrSint64IntAPS"); break; case OP_ShrUint64Sint8: Text.Op = PrintName("ShrUint64Sint8"); break; case OP_ShrUint64Uint8: Text.Op = PrintName("ShrUint64Uint8"); break; case OP_ShrUint64Sint16: Text.Op = PrintName("ShrUint64Sint16"); break; case OP_ShrUint64Uint16: Text.Op = PrintName("ShrUint64Uint16"); break; case OP_ShrUint64Sint32: Text.Op = PrintName("ShrUint64Sint32"); break; case OP_ShrUint64Uint32: Text.Op = PrintName("ShrUint64Uint32"); break; case OP_ShrUint64Sint64: Text.Op = PrintName("ShrUint64Sint64"); break; case OP_ShrUint64Uint64: Text.Op = PrintName("ShrUint64Uint64"); break; case OP_ShrUint64IntAP: Text.Op = PrintName("ShrUint64IntAP"); break; case OP_ShrUint64IntAPS: Text.Op = PrintName("ShrUint64IntAPS"); break; case OP_ShrIntAPSint8: Text.Op = PrintName("ShrIntAPSint8"); break; case OP_ShrIntAPUint8: Text.Op = PrintName("ShrIntAPUint8"); break; case OP_ShrIntAPSint16: Text.Op = PrintName("ShrIntAPSint16"); break; case OP_ShrIntAPUint16: Text.Op = PrintName("ShrIntAPUint16"); break; case OP_ShrIntAPSint32: Text.Op = PrintName("ShrIntAPSint32"); break; case OP_ShrIntAPUint32: Text.Op = PrintName("ShrIntAPUint32"); break; case OP_ShrIntAPSint64: Text.Op = PrintName("ShrIntAPSint64"); break; case OP_ShrIntAPUint64: Text.Op = PrintName("ShrIntAPUint64"); break; case OP_ShrIntAPIntAP: Text.Op = PrintName("ShrIntAPIntAP"); break; case OP_ShrIntAPIntAPS: Text.Op = PrintName("ShrIntAPIntAPS"); break; case OP_ShrIntAPSSint8: Text.Op = PrintName("ShrIntAPSSint8"); break; case OP_ShrIntAPSUint8: Text.Op = PrintName("ShrIntAPSUint8"); break; case OP_ShrIntAPSSint16: Text.Op = PrintName("ShrIntAPSSint16"); break; case OP_ShrIntAPSUint16: Text.Op = PrintName("ShrIntAPSUint16"); break; case OP_ShrIntAPSSint32: Text.Op = PrintName("ShrIntAPSSint32"); break; case OP_ShrIntAPSUint32: Text.Op = PrintName("ShrIntAPSUint32"); break; case OP_ShrIntAPSSint64: Text.Op = PrintName("ShrIntAPSSint64"); break; case OP_ShrIntAPSUint64: Text.Op = PrintName("ShrIntAPSUint64"); break; case OP_ShrIntAPSIntAP: Text.Op = PrintName("ShrIntAPSIntAP"); break; case OP_ShrIntAPSIntAPS: Text.Op = PrintName("ShrIntAPSIntAPS"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitShrSint8Sint8(const SourceInfo &); bool emitShrSint8Uint8(const SourceInfo &); bool emitShrSint8Sint16(const SourceInfo &); bool emitShrSint8Uint16(const SourceInfo &); bool emitShrSint8Sint32(const SourceInfo &); bool emitShrSint8Uint32(const SourceInfo &); bool emitShrSint8Sint64(const SourceInfo &); bool emitShrSint8Uint64(const SourceInfo &); bool emitShrSint8IntAP(const SourceInfo &); bool emitShrSint8IntAPS(const SourceInfo &); bool emitShrUint8Sint8(const SourceInfo &); bool emitShrUint8Uint8(const SourceInfo &); bool emitShrUint8Sint16(const SourceInfo &); bool emitShrUint8Uint16(const SourceInfo &); bool emitShrUint8Sint32(const SourceInfo &); bool emitShrUint8Uint32(const SourceInfo &); bool emitShrUint8Sint64(const SourceInfo &); bool emitShrUint8Uint64(const SourceInfo &); bool emitShrUint8IntAP(const SourceInfo &); bool emitShrUint8IntAPS(const SourceInfo &); bool emitShrSint16Sint8(const SourceInfo &); bool emitShrSint16Uint8(const SourceInfo &); bool emitShrSint16Sint16(const SourceInfo &); bool emitShrSint16Uint16(const SourceInfo &); bool emitShrSint16Sint32(const SourceInfo &); bool emitShrSint16Uint32(const SourceInfo &); bool emitShrSint16Sint64(const SourceInfo &); bool emitShrSint16Uint64(const SourceInfo &); bool emitShrSint16IntAP(const SourceInfo &); bool emitShrSint16IntAPS(const SourceInfo &); bool emitShrUint16Sint8(const SourceInfo &); bool emitShrUint16Uint8(const SourceInfo &); bool emitShrUint16Sint16(const SourceInfo &); bool emitShrUint16Uint16(const SourceInfo &); bool emitShrUint16Sint32(const SourceInfo &); bool emitShrUint16Uint32(const SourceInfo &); bool emitShrUint16Sint64(const SourceInfo &); bool emitShrUint16Uint64(const SourceInfo &); bool emitShrUint16IntAP(const SourceInfo &); bool emitShrUint16IntAPS(const SourceInfo &); bool emitShrSint32Sint8(const SourceInfo &); bool emitShrSint32Uint8(const SourceInfo &); bool emitShrSint32Sint16(const SourceInfo &); bool emitShrSint32Uint16(const SourceInfo &); bool emitShrSint32Sint32(const SourceInfo &); bool emitShrSint32Uint32(const SourceInfo &); bool emitShrSint32Sint64(const SourceInfo &); bool emitShrSint32Uint64(const SourceInfo &); bool emitShrSint32IntAP(const SourceInfo &); bool emitShrSint32IntAPS(const SourceInfo &); bool emitShrUint32Sint8(const SourceInfo &); bool emitShrUint32Uint8(const SourceInfo &); bool emitShrUint32Sint16(const SourceInfo &); bool emitShrUint32Uint16(const SourceInfo &); bool emitShrUint32Sint32(const SourceInfo &); bool emitShrUint32Uint32(const SourceInfo &); bool emitShrUint32Sint64(const SourceInfo &); bool emitShrUint32Uint64(const SourceInfo &); bool emitShrUint32IntAP(const SourceInfo &); bool emitShrUint32IntAPS(const SourceInfo &); bool emitShrSint64Sint8(const SourceInfo &); bool emitShrSint64Uint8(const SourceInfo &); bool emitShrSint64Sint16(const SourceInfo &); bool emitShrSint64Uint16(const SourceInfo &); bool emitShrSint64Sint32(const SourceInfo &); bool emitShrSint64Uint32(const SourceInfo &); bool emitShrSint64Sint64(const SourceInfo &); bool emitShrSint64Uint64(const SourceInfo &); bool emitShrSint64IntAP(const SourceInfo &); bool emitShrSint64IntAPS(const SourceInfo &); bool emitShrUint64Sint8(const SourceInfo &); bool emitShrUint64Uint8(const SourceInfo &); bool emitShrUint64Sint16(const SourceInfo &); bool emitShrUint64Uint16(const SourceInfo &); bool emitShrUint64Sint32(const SourceInfo &); bool emitShrUint64Uint32(const SourceInfo &); bool emitShrUint64Sint64(const SourceInfo &); bool emitShrUint64Uint64(const SourceInfo &); bool emitShrUint64IntAP(const SourceInfo &); bool emitShrUint64IntAPS(const SourceInfo &); bool emitShrIntAPSint8(const SourceInfo &); bool emitShrIntAPUint8(const SourceInfo &); bool emitShrIntAPSint16(const SourceInfo &); bool emitShrIntAPUint16(const SourceInfo &); bool emitShrIntAPSint32(const SourceInfo &); bool emitShrIntAPUint32(const SourceInfo &); bool emitShrIntAPSint64(const SourceInfo &); bool emitShrIntAPUint64(const SourceInfo &); bool emitShrIntAPIntAP(const SourceInfo &); bool emitShrIntAPIntAPS(const SourceInfo &); bool emitShrIntAPSSint8(const SourceInfo &); bool emitShrIntAPSUint8(const SourceInfo &); bool emitShrIntAPSSint16(const SourceInfo &); bool emitShrIntAPSUint16(const SourceInfo &); bool emitShrIntAPSSint32(const SourceInfo &); bool emitShrIntAPSUint32(const SourceInfo &); bool emitShrIntAPSSint64(const SourceInfo &); bool emitShrIntAPSUint64(const SourceInfo &); bool emitShrIntAPSIntAP(const SourceInfo &); bool emitShrIntAPSIntAPS(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitShr(PrimType, PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitShr(PrimType T0, PrimType T1, const SourceInfo &I) { switch (T0) { case PT_Sint8: switch (T1) { case PT_Sint8: return emitShrSint8Sint8(I); case PT_Uint8: return emitShrSint8Uint8(I); case PT_Sint16: return emitShrSint8Sint16(I); case PT_Uint16: return emitShrSint8Uint16(I); case PT_Sint32: return emitShrSint8Sint32(I); case PT_Uint32: return emitShrSint8Uint32(I); case PT_Sint64: return emitShrSint8Sint64(I); case PT_Uint64: return emitShrSint8Uint64(I); case PT_IntAP: return emitShrSint8IntAP(I); case PT_IntAPS: return emitShrSint8IntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); case PT_Uint8: switch (T1) { case PT_Sint8: return emitShrUint8Sint8(I); case PT_Uint8: return emitShrUint8Uint8(I); case PT_Sint16: return emitShrUint8Sint16(I); case PT_Uint16: return emitShrUint8Uint16(I); case PT_Sint32: return emitShrUint8Sint32(I); case PT_Uint32: return emitShrUint8Uint32(I); case PT_Sint64: return emitShrUint8Sint64(I); case PT_Uint64: return emitShrUint8Uint64(I); case PT_IntAP: return emitShrUint8IntAP(I); case PT_IntAPS: return emitShrUint8IntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); case PT_Sint16: switch (T1) { case PT_Sint8: return emitShrSint16Sint8(I); case PT_Uint8: return emitShrSint16Uint8(I); case PT_Sint16: return emitShrSint16Sint16(I); case PT_Uint16: return emitShrSint16Uint16(I); case PT_Sint32: return emitShrSint16Sint32(I); case PT_Uint32: return emitShrSint16Uint32(I); case PT_Sint64: return emitShrSint16Sint64(I); case PT_Uint64: return emitShrSint16Uint64(I); case PT_IntAP: return emitShrSint16IntAP(I); case PT_IntAPS: return emitShrSint16IntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); case PT_Uint16: switch (T1) { case PT_Sint8: return emitShrUint16Sint8(I); case PT_Uint8: return emitShrUint16Uint8(I); case PT_Sint16: return emitShrUint16Sint16(I); case PT_Uint16: return emitShrUint16Uint16(I); case PT_Sint32: return emitShrUint16Sint32(I); case PT_Uint32: return emitShrUint16Uint32(I); case PT_Sint64: return emitShrUint16Sint64(I); case PT_Uint64: return emitShrUint16Uint64(I); case PT_IntAP: return emitShrUint16IntAP(I); case PT_IntAPS: return emitShrUint16IntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); case PT_Sint32: switch (T1) { case PT_Sint8: return emitShrSint32Sint8(I); case PT_Uint8: return emitShrSint32Uint8(I); case PT_Sint16: return emitShrSint32Sint16(I); case PT_Uint16: return emitShrSint32Uint16(I); case PT_Sint32: return emitShrSint32Sint32(I); case PT_Uint32: return emitShrSint32Uint32(I); case PT_Sint64: return emitShrSint32Sint64(I); case PT_Uint64: return emitShrSint32Uint64(I); case PT_IntAP: return emitShrSint32IntAP(I); case PT_IntAPS: return emitShrSint32IntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); case PT_Uint32: switch (T1) { case PT_Sint8: return emitShrUint32Sint8(I); case PT_Uint8: return emitShrUint32Uint8(I); case PT_Sint16: return emitShrUint32Sint16(I); case PT_Uint16: return emitShrUint32Uint16(I); case PT_Sint32: return emitShrUint32Sint32(I); case PT_Uint32: return emitShrUint32Uint32(I); case PT_Sint64: return emitShrUint32Sint64(I); case PT_Uint64: return emitShrUint32Uint64(I); case PT_IntAP: return emitShrUint32IntAP(I); case PT_IntAPS: return emitShrUint32IntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); case PT_Sint64: switch (T1) { case PT_Sint8: return emitShrSint64Sint8(I); case PT_Uint8: return emitShrSint64Uint8(I); case PT_Sint16: return emitShrSint64Sint16(I); case PT_Uint16: return emitShrSint64Uint16(I); case PT_Sint32: return emitShrSint64Sint32(I); case PT_Uint32: return emitShrSint64Uint32(I); case PT_Sint64: return emitShrSint64Sint64(I); case PT_Uint64: return emitShrSint64Uint64(I); case PT_IntAP: return emitShrSint64IntAP(I); case PT_IntAPS: return emitShrSint64IntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); case PT_Uint64: switch (T1) { case PT_Sint8: return emitShrUint64Sint8(I); case PT_Uint8: return emitShrUint64Uint8(I); case PT_Sint16: return emitShrUint64Sint16(I); case PT_Uint16: return emitShrUint64Uint16(I); case PT_Sint32: return emitShrUint64Sint32(I); case PT_Uint32: return emitShrUint64Uint32(I); case PT_Sint64: return emitShrUint64Sint64(I); case PT_Uint64: return emitShrUint64Uint64(I); case PT_IntAP: return emitShrUint64IntAP(I); case PT_IntAPS: return emitShrUint64IntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); case PT_IntAP: switch (T1) { case PT_Sint8: return emitShrIntAPSint8(I); case PT_Uint8: return emitShrIntAPUint8(I); case PT_Sint16: return emitShrIntAPSint16(I); case PT_Uint16: return emitShrIntAPUint16(I); case PT_Sint32: return emitShrIntAPSint32(I); case PT_Uint32: return emitShrIntAPUint32(I); case PT_Sint64: return emitShrIntAPSint64(I); case PT_Uint64: return emitShrIntAPUint64(I); case PT_IntAP: return emitShrIntAPIntAP(I); case PT_IntAPS: return emitShrIntAPIntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); case PT_IntAPS: switch (T1) { case PT_Sint8: return emitShrIntAPSSint8(I); case PT_Uint8: return emitShrIntAPSUint8(I); case PT_Sint16: return emitShrIntAPSSint16(I); case PT_Uint16: return emitShrIntAPSUint16(I); case PT_Sint32: return emitShrIntAPSSint32(I); case PT_Uint32: return emitShrIntAPSUint32(I); case PT_Sint64: return emitShrIntAPSSint64(I); case PT_Uint64: return emitShrIntAPSUint64(I); case PT_IntAP: return emitShrIntAPSIntAP(I); case PT_IntAPS: return emitShrIntAPSIntAPS(I); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); default: llvm_unreachable("invalid type: emitShr"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitShrSint8Sint8(const SourceInfo &L) { return emitOp<>(OP_ShrSint8Sint8, L); } bool ByteCodeEmitter::emitShrSint8Uint8(const SourceInfo &L) { return emitOp<>(OP_ShrSint8Uint8, L); } bool ByteCodeEmitter::emitShrSint8Sint16(const SourceInfo &L) { return emitOp<>(OP_ShrSint8Sint16, L); } bool ByteCodeEmitter::emitShrSint8Uint16(const SourceInfo &L) { return emitOp<>(OP_ShrSint8Uint16, L); } bool ByteCodeEmitter::emitShrSint8Sint32(const SourceInfo &L) { return emitOp<>(OP_ShrSint8Sint32, L); } bool ByteCodeEmitter::emitShrSint8Uint32(const SourceInfo &L) { return emitOp<>(OP_ShrSint8Uint32, L); } bool ByteCodeEmitter::emitShrSint8Sint64(const SourceInfo &L) { return emitOp<>(OP_ShrSint8Sint64, L); } bool ByteCodeEmitter::emitShrSint8Uint64(const SourceInfo &L) { return emitOp<>(OP_ShrSint8Uint64, L); } bool ByteCodeEmitter::emitShrSint8IntAP(const SourceInfo &L) { return emitOp<>(OP_ShrSint8IntAP, L); } bool ByteCodeEmitter::emitShrSint8IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrSint8IntAPS, L); } bool ByteCodeEmitter::emitShrUint8Sint8(const SourceInfo &L) { return emitOp<>(OP_ShrUint8Sint8, L); } bool ByteCodeEmitter::emitShrUint8Uint8(const SourceInfo &L) { return emitOp<>(OP_ShrUint8Uint8, L); } bool ByteCodeEmitter::emitShrUint8Sint16(const SourceInfo &L) { return emitOp<>(OP_ShrUint8Sint16, L); } bool ByteCodeEmitter::emitShrUint8Uint16(const SourceInfo &L) { return emitOp<>(OP_ShrUint8Uint16, L); } bool ByteCodeEmitter::emitShrUint8Sint32(const SourceInfo &L) { return emitOp<>(OP_ShrUint8Sint32, L); } bool ByteCodeEmitter::emitShrUint8Uint32(const SourceInfo &L) { return emitOp<>(OP_ShrUint8Uint32, L); } bool ByteCodeEmitter::emitShrUint8Sint64(const SourceInfo &L) { return emitOp<>(OP_ShrUint8Sint64, L); } bool ByteCodeEmitter::emitShrUint8Uint64(const SourceInfo &L) { return emitOp<>(OP_ShrUint8Uint64, L); } bool ByteCodeEmitter::emitShrUint8IntAP(const SourceInfo &L) { return emitOp<>(OP_ShrUint8IntAP, L); } bool ByteCodeEmitter::emitShrUint8IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrUint8IntAPS, L); } bool ByteCodeEmitter::emitShrSint16Sint8(const SourceInfo &L) { return emitOp<>(OP_ShrSint16Sint8, L); } bool ByteCodeEmitter::emitShrSint16Uint8(const SourceInfo &L) { return emitOp<>(OP_ShrSint16Uint8, L); } bool ByteCodeEmitter::emitShrSint16Sint16(const SourceInfo &L) { return emitOp<>(OP_ShrSint16Sint16, L); } bool ByteCodeEmitter::emitShrSint16Uint16(const SourceInfo &L) { return emitOp<>(OP_ShrSint16Uint16, L); } bool ByteCodeEmitter::emitShrSint16Sint32(const SourceInfo &L) { return emitOp<>(OP_ShrSint16Sint32, L); } bool ByteCodeEmitter::emitShrSint16Uint32(const SourceInfo &L) { return emitOp<>(OP_ShrSint16Uint32, L); } bool ByteCodeEmitter::emitShrSint16Sint64(const SourceInfo &L) { return emitOp<>(OP_ShrSint16Sint64, L); } bool ByteCodeEmitter::emitShrSint16Uint64(const SourceInfo &L) { return emitOp<>(OP_ShrSint16Uint64, L); } bool ByteCodeEmitter::emitShrSint16IntAP(const SourceInfo &L) { return emitOp<>(OP_ShrSint16IntAP, L); } bool ByteCodeEmitter::emitShrSint16IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrSint16IntAPS, L); } bool ByteCodeEmitter::emitShrUint16Sint8(const SourceInfo &L) { return emitOp<>(OP_ShrUint16Sint8, L); } bool ByteCodeEmitter::emitShrUint16Uint8(const SourceInfo &L) { return emitOp<>(OP_ShrUint16Uint8, L); } bool ByteCodeEmitter::emitShrUint16Sint16(const SourceInfo &L) { return emitOp<>(OP_ShrUint16Sint16, L); } bool ByteCodeEmitter::emitShrUint16Uint16(const SourceInfo &L) { return emitOp<>(OP_ShrUint16Uint16, L); } bool ByteCodeEmitter::emitShrUint16Sint32(const SourceInfo &L) { return emitOp<>(OP_ShrUint16Sint32, L); } bool ByteCodeEmitter::emitShrUint16Uint32(const SourceInfo &L) { return emitOp<>(OP_ShrUint16Uint32, L); } bool ByteCodeEmitter::emitShrUint16Sint64(const SourceInfo &L) { return emitOp<>(OP_ShrUint16Sint64, L); } bool ByteCodeEmitter::emitShrUint16Uint64(const SourceInfo &L) { return emitOp<>(OP_ShrUint16Uint64, L); } bool ByteCodeEmitter::emitShrUint16IntAP(const SourceInfo &L) { return emitOp<>(OP_ShrUint16IntAP, L); } bool ByteCodeEmitter::emitShrUint16IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrUint16IntAPS, L); } bool ByteCodeEmitter::emitShrSint32Sint8(const SourceInfo &L) { return emitOp<>(OP_ShrSint32Sint8, L); } bool ByteCodeEmitter::emitShrSint32Uint8(const SourceInfo &L) { return emitOp<>(OP_ShrSint32Uint8, L); } bool ByteCodeEmitter::emitShrSint32Sint16(const SourceInfo &L) { return emitOp<>(OP_ShrSint32Sint16, L); } bool ByteCodeEmitter::emitShrSint32Uint16(const SourceInfo &L) { return emitOp<>(OP_ShrSint32Uint16, L); } bool ByteCodeEmitter::emitShrSint32Sint32(const SourceInfo &L) { return emitOp<>(OP_ShrSint32Sint32, L); } bool ByteCodeEmitter::emitShrSint32Uint32(const SourceInfo &L) { return emitOp<>(OP_ShrSint32Uint32, L); } bool ByteCodeEmitter::emitShrSint32Sint64(const SourceInfo &L) { return emitOp<>(OP_ShrSint32Sint64, L); } bool ByteCodeEmitter::emitShrSint32Uint64(const SourceInfo &L) { return emitOp<>(OP_ShrSint32Uint64, L); } bool ByteCodeEmitter::emitShrSint32IntAP(const SourceInfo &L) { return emitOp<>(OP_ShrSint32IntAP, L); } bool ByteCodeEmitter::emitShrSint32IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrSint32IntAPS, L); } bool ByteCodeEmitter::emitShrUint32Sint8(const SourceInfo &L) { return emitOp<>(OP_ShrUint32Sint8, L); } bool ByteCodeEmitter::emitShrUint32Uint8(const SourceInfo &L) { return emitOp<>(OP_ShrUint32Uint8, L); } bool ByteCodeEmitter::emitShrUint32Sint16(const SourceInfo &L) { return emitOp<>(OP_ShrUint32Sint16, L); } bool ByteCodeEmitter::emitShrUint32Uint16(const SourceInfo &L) { return emitOp<>(OP_ShrUint32Uint16, L); } bool ByteCodeEmitter::emitShrUint32Sint32(const SourceInfo &L) { return emitOp<>(OP_ShrUint32Sint32, L); } bool ByteCodeEmitter::emitShrUint32Uint32(const SourceInfo &L) { return emitOp<>(OP_ShrUint32Uint32, L); } bool ByteCodeEmitter::emitShrUint32Sint64(const SourceInfo &L) { return emitOp<>(OP_ShrUint32Sint64, L); } bool ByteCodeEmitter::emitShrUint32Uint64(const SourceInfo &L) { return emitOp<>(OP_ShrUint32Uint64, L); } bool ByteCodeEmitter::emitShrUint32IntAP(const SourceInfo &L) { return emitOp<>(OP_ShrUint32IntAP, L); } bool ByteCodeEmitter::emitShrUint32IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrUint32IntAPS, L); } bool ByteCodeEmitter::emitShrSint64Sint8(const SourceInfo &L) { return emitOp<>(OP_ShrSint64Sint8, L); } bool ByteCodeEmitter::emitShrSint64Uint8(const SourceInfo &L) { return emitOp<>(OP_ShrSint64Uint8, L); } bool ByteCodeEmitter::emitShrSint64Sint16(const SourceInfo &L) { return emitOp<>(OP_ShrSint64Sint16, L); } bool ByteCodeEmitter::emitShrSint64Uint16(const SourceInfo &L) { return emitOp<>(OP_ShrSint64Uint16, L); } bool ByteCodeEmitter::emitShrSint64Sint32(const SourceInfo &L) { return emitOp<>(OP_ShrSint64Sint32, L); } bool ByteCodeEmitter::emitShrSint64Uint32(const SourceInfo &L) { return emitOp<>(OP_ShrSint64Uint32, L); } bool ByteCodeEmitter::emitShrSint64Sint64(const SourceInfo &L) { return emitOp<>(OP_ShrSint64Sint64, L); } bool ByteCodeEmitter::emitShrSint64Uint64(const SourceInfo &L) { return emitOp<>(OP_ShrSint64Uint64, L); } bool ByteCodeEmitter::emitShrSint64IntAP(const SourceInfo &L) { return emitOp<>(OP_ShrSint64IntAP, L); } bool ByteCodeEmitter::emitShrSint64IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrSint64IntAPS, L); } bool ByteCodeEmitter::emitShrUint64Sint8(const SourceInfo &L) { return emitOp<>(OP_ShrUint64Sint8, L); } bool ByteCodeEmitter::emitShrUint64Uint8(const SourceInfo &L) { return emitOp<>(OP_ShrUint64Uint8, L); } bool ByteCodeEmitter::emitShrUint64Sint16(const SourceInfo &L) { return emitOp<>(OP_ShrUint64Sint16, L); } bool ByteCodeEmitter::emitShrUint64Uint16(const SourceInfo &L) { return emitOp<>(OP_ShrUint64Uint16, L); } bool ByteCodeEmitter::emitShrUint64Sint32(const SourceInfo &L) { return emitOp<>(OP_ShrUint64Sint32, L); } bool ByteCodeEmitter::emitShrUint64Uint32(const SourceInfo &L) { return emitOp<>(OP_ShrUint64Uint32, L); } bool ByteCodeEmitter::emitShrUint64Sint64(const SourceInfo &L) { return emitOp<>(OP_ShrUint64Sint64, L); } bool ByteCodeEmitter::emitShrUint64Uint64(const SourceInfo &L) { return emitOp<>(OP_ShrUint64Uint64, L); } bool ByteCodeEmitter::emitShrUint64IntAP(const SourceInfo &L) { return emitOp<>(OP_ShrUint64IntAP, L); } bool ByteCodeEmitter::emitShrUint64IntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrUint64IntAPS, L); } bool ByteCodeEmitter::emitShrIntAPSint8(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSint8, L); } bool ByteCodeEmitter::emitShrIntAPUint8(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPUint8, L); } bool ByteCodeEmitter::emitShrIntAPSint16(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSint16, L); } bool ByteCodeEmitter::emitShrIntAPUint16(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPUint16, L); } bool ByteCodeEmitter::emitShrIntAPSint32(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSint32, L); } bool ByteCodeEmitter::emitShrIntAPUint32(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPUint32, L); } bool ByteCodeEmitter::emitShrIntAPSint64(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSint64, L); } bool ByteCodeEmitter::emitShrIntAPUint64(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPUint64, L); } bool ByteCodeEmitter::emitShrIntAPIntAP(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPIntAP, L); } bool ByteCodeEmitter::emitShrIntAPIntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPIntAPS, L); } bool ByteCodeEmitter::emitShrIntAPSSint8(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSSint8, L); } bool ByteCodeEmitter::emitShrIntAPSUint8(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSUint8, L); } bool ByteCodeEmitter::emitShrIntAPSSint16(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSSint16, L); } bool ByteCodeEmitter::emitShrIntAPSUint16(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSUint16, L); } bool ByteCodeEmitter::emitShrIntAPSSint32(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSSint32, L); } bool ByteCodeEmitter::emitShrIntAPSUint32(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSUint32, L); } bool ByteCodeEmitter::emitShrIntAPSSint64(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSSint64, L); } bool ByteCodeEmitter::emitShrIntAPSUint64(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSUint64, L); } bool ByteCodeEmitter::emitShrIntAPSIntAP(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSIntAP, L); } bool ByteCodeEmitter::emitShrIntAPSIntAPS(const SourceInfo &L) { return emitOp<>(OP_ShrIntAPSIntAPS, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitShrSint8Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint8Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint8Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint8Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint8Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint8Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint8Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint8Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint8IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint8IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint8IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint16IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint16IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint32IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint32IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrSint64IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64Sint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64Uint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64Sint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64Uint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64Sint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64Uint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64Sint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64Uint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64IntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrUint64IntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } bool EvalEmitter::emitShrIntAPSIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Shr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_SideEffect, #endif #ifdef GET_INTERP case OP_SideEffect: { if (!SideEffect(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_SideEffect: Text.Op = PrintName("SideEffect"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSideEffect(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSideEffect(const SourceInfo &L) { return emitOp<>(OP_SideEffect, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSideEffect(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SideEffect(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_SizelessVectorElementSize, #endif #ifdef GET_INTERP case OP_SizelessVectorElementSize: { if (!SizelessVectorElementSize(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_SizelessVectorElementSize: Text.Op = PrintName("SizelessVectorElementSize"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSizelessVectorElementSize(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSizelessVectorElementSize(const SourceInfo &L) { return emitOp<>(OP_SizelessVectorElementSize, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSizelessVectorElementSize(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SizelessVectorElementSize(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StartLifetime, #endif #ifdef GET_INTERP case OP_StartLifetime: { if (!StartLifetime(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StartLifetime: Text.Op = PrintName("StartLifetime"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStartLifetime(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStartLifetime(const SourceInfo &L) { return emitOp<>(OP_StartLifetime, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStartLifetime(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StartLifetime(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StartSpeculation, #endif #ifdef GET_INTERP case OP_StartSpeculation: { if (!StartSpeculation(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StartSpeculation: Text.Op = PrintName("StartSpeculation"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStartSpeculation(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStartSpeculation(const SourceInfo &L) { return emitOp<>(OP_StartSpeculation, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStartSpeculation(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StartSpeculation(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StoreSint8, OP_StoreUint8, OP_StoreSint16, OP_StoreUint16, OP_StoreSint32, OP_StoreUint32, OP_StoreSint64, OP_StoreUint64, OP_StoreIntAP, OP_StoreIntAPS, OP_StoreBool, OP_StoreFixedPoint, OP_StorePtr, OP_StoreMemberPtr, OP_StoreFloat, #endif #ifdef GET_INTERP case OP_StoreSint8: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreUint8: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreSint16: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreUint16: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreSint32: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreUint32: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreSint64: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreUint64: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreIntAP: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreIntAPS: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreBool: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreFixedPoint: { if (!Store(S, OpPC)) return false; continue; } case OP_StorePtr: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreMemberPtr: { if (!Store(S, OpPC)) return false; continue; } case OP_StoreFloat: { if (!Store(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StoreSint8: Text.Op = PrintName("StoreSint8"); break; case OP_StoreUint8: Text.Op = PrintName("StoreUint8"); break; case OP_StoreSint16: Text.Op = PrintName("StoreSint16"); break; case OP_StoreUint16: Text.Op = PrintName("StoreUint16"); break; case OP_StoreSint32: Text.Op = PrintName("StoreSint32"); break; case OP_StoreUint32: Text.Op = PrintName("StoreUint32"); break; case OP_StoreSint64: Text.Op = PrintName("StoreSint64"); break; case OP_StoreUint64: Text.Op = PrintName("StoreUint64"); break; case OP_StoreIntAP: Text.Op = PrintName("StoreIntAP"); break; case OP_StoreIntAPS: Text.Op = PrintName("StoreIntAPS"); break; case OP_StoreBool: Text.Op = PrintName("StoreBool"); break; case OP_StoreFixedPoint: Text.Op = PrintName("StoreFixedPoint"); break; case OP_StorePtr: Text.Op = PrintName("StorePtr"); break; case OP_StoreMemberPtr: Text.Op = PrintName("StoreMemberPtr"); break; case OP_StoreFloat: Text.Op = PrintName("StoreFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStoreSint8(const SourceInfo &); bool emitStoreUint8(const SourceInfo &); bool emitStoreSint16(const SourceInfo &); bool emitStoreUint16(const SourceInfo &); bool emitStoreSint32(const SourceInfo &); bool emitStoreUint32(const SourceInfo &); bool emitStoreSint64(const SourceInfo &); bool emitStoreUint64(const SourceInfo &); bool emitStoreIntAP(const SourceInfo &); bool emitStoreIntAPS(const SourceInfo &); bool emitStoreBool(const SourceInfo &); bool emitStoreFixedPoint(const SourceInfo &); bool emitStorePtr(const SourceInfo &); bool emitStoreMemberPtr(const SourceInfo &); bool emitStoreFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitStore(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitStore(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitStoreSint8(I); case PT_Uint8: return emitStoreUint8(I); case PT_Sint16: return emitStoreSint16(I); case PT_Uint16: return emitStoreUint16(I); case PT_Sint32: return emitStoreSint32(I); case PT_Uint32: return emitStoreUint32(I); case PT_Sint64: return emitStoreSint64(I); case PT_Uint64: return emitStoreUint64(I); case PT_IntAP: return emitStoreIntAP(I); case PT_IntAPS: return emitStoreIntAPS(I); case PT_Bool: return emitStoreBool(I); case PT_FixedPoint: return emitStoreFixedPoint(I); case PT_Ptr: return emitStorePtr(I); case PT_MemberPtr: return emitStoreMemberPtr(I); case PT_Float: return emitStoreFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStoreSint8(const SourceInfo &L) { return emitOp<>(OP_StoreSint8, L); } bool ByteCodeEmitter::emitStoreUint8(const SourceInfo &L) { return emitOp<>(OP_StoreUint8, L); } bool ByteCodeEmitter::emitStoreSint16(const SourceInfo &L) { return emitOp<>(OP_StoreSint16, L); } bool ByteCodeEmitter::emitStoreUint16(const SourceInfo &L) { return emitOp<>(OP_StoreUint16, L); } bool ByteCodeEmitter::emitStoreSint32(const SourceInfo &L) { return emitOp<>(OP_StoreSint32, L); } bool ByteCodeEmitter::emitStoreUint32(const SourceInfo &L) { return emitOp<>(OP_StoreUint32, L); } bool ByteCodeEmitter::emitStoreSint64(const SourceInfo &L) { return emitOp<>(OP_StoreSint64, L); } bool ByteCodeEmitter::emitStoreUint64(const SourceInfo &L) { return emitOp<>(OP_StoreUint64, L); } bool ByteCodeEmitter::emitStoreIntAP(const SourceInfo &L) { return emitOp<>(OP_StoreIntAP, L); } bool ByteCodeEmitter::emitStoreIntAPS(const SourceInfo &L) { return emitOp<>(OP_StoreIntAPS, L); } bool ByteCodeEmitter::emitStoreBool(const SourceInfo &L) { return emitOp<>(OP_StoreBool, L); } bool ByteCodeEmitter::emitStoreFixedPoint(const SourceInfo &L) { return emitOp<>(OP_StoreFixedPoint, L); } bool ByteCodeEmitter::emitStorePtr(const SourceInfo &L) { return emitOp<>(OP_StorePtr, L); } bool ByteCodeEmitter::emitStoreMemberPtr(const SourceInfo &L) { return emitOp<>(OP_StoreMemberPtr, L); } bool ByteCodeEmitter::emitStoreFloat(const SourceInfo &L) { return emitOp<>(OP_StoreFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStoreSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStorePtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } bool EvalEmitter::emitStoreFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Store(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StoreActivateSint8, OP_StoreActivateUint8, OP_StoreActivateSint16, OP_StoreActivateUint16, OP_StoreActivateSint32, OP_StoreActivateUint32, OP_StoreActivateSint64, OP_StoreActivateUint64, OP_StoreActivateIntAP, OP_StoreActivateIntAPS, OP_StoreActivateBool, OP_StoreActivateFixedPoint, OP_StoreActivatePtr, OP_StoreActivateMemberPtr, OP_StoreActivateFloat, #endif #ifdef GET_INTERP case OP_StoreActivateSint8: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateUint8: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateSint16: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateUint16: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateSint32: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateUint32: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateSint64: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateUint64: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateIntAP: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateIntAPS: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateBool: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateFixedPoint: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivatePtr: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateMemberPtr: { if (!StoreActivate(S, OpPC)) return false; continue; } case OP_StoreActivateFloat: { if (!StoreActivate(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StoreActivateSint8: Text.Op = PrintName("StoreActivateSint8"); break; case OP_StoreActivateUint8: Text.Op = PrintName("StoreActivateUint8"); break; case OP_StoreActivateSint16: Text.Op = PrintName("StoreActivateSint16"); break; case OP_StoreActivateUint16: Text.Op = PrintName("StoreActivateUint16"); break; case OP_StoreActivateSint32: Text.Op = PrintName("StoreActivateSint32"); break; case OP_StoreActivateUint32: Text.Op = PrintName("StoreActivateUint32"); break; case OP_StoreActivateSint64: Text.Op = PrintName("StoreActivateSint64"); break; case OP_StoreActivateUint64: Text.Op = PrintName("StoreActivateUint64"); break; case OP_StoreActivateIntAP: Text.Op = PrintName("StoreActivateIntAP"); break; case OP_StoreActivateIntAPS: Text.Op = PrintName("StoreActivateIntAPS"); break; case OP_StoreActivateBool: Text.Op = PrintName("StoreActivateBool"); break; case OP_StoreActivateFixedPoint: Text.Op = PrintName("StoreActivateFixedPoint"); break; case OP_StoreActivatePtr: Text.Op = PrintName("StoreActivatePtr"); break; case OP_StoreActivateMemberPtr: Text.Op = PrintName("StoreActivateMemberPtr"); break; case OP_StoreActivateFloat: Text.Op = PrintName("StoreActivateFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStoreActivateSint8(const SourceInfo &); bool emitStoreActivateUint8(const SourceInfo &); bool emitStoreActivateSint16(const SourceInfo &); bool emitStoreActivateUint16(const SourceInfo &); bool emitStoreActivateSint32(const SourceInfo &); bool emitStoreActivateUint32(const SourceInfo &); bool emitStoreActivateSint64(const SourceInfo &); bool emitStoreActivateUint64(const SourceInfo &); bool emitStoreActivateIntAP(const SourceInfo &); bool emitStoreActivateIntAPS(const SourceInfo &); bool emitStoreActivateBool(const SourceInfo &); bool emitStoreActivateFixedPoint(const SourceInfo &); bool emitStoreActivatePtr(const SourceInfo &); bool emitStoreActivateMemberPtr(const SourceInfo &); bool emitStoreActivateFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitStoreActivate(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitStoreActivate(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitStoreActivateSint8(I); case PT_Uint8: return emitStoreActivateUint8(I); case PT_Sint16: return emitStoreActivateSint16(I); case PT_Uint16: return emitStoreActivateUint16(I); case PT_Sint32: return emitStoreActivateSint32(I); case PT_Uint32: return emitStoreActivateUint32(I); case PT_Sint64: return emitStoreActivateSint64(I); case PT_Uint64: return emitStoreActivateUint64(I); case PT_IntAP: return emitStoreActivateIntAP(I); case PT_IntAPS: return emitStoreActivateIntAPS(I); case PT_Bool: return emitStoreActivateBool(I); case PT_FixedPoint: return emitStoreActivateFixedPoint(I); case PT_Ptr: return emitStoreActivatePtr(I); case PT_MemberPtr: return emitStoreActivateMemberPtr(I); case PT_Float: return emitStoreActivateFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStoreActivateSint8(const SourceInfo &L) { return emitOp<>(OP_StoreActivateSint8, L); } bool ByteCodeEmitter::emitStoreActivateUint8(const SourceInfo &L) { return emitOp<>(OP_StoreActivateUint8, L); } bool ByteCodeEmitter::emitStoreActivateSint16(const SourceInfo &L) { return emitOp<>(OP_StoreActivateSint16, L); } bool ByteCodeEmitter::emitStoreActivateUint16(const SourceInfo &L) { return emitOp<>(OP_StoreActivateUint16, L); } bool ByteCodeEmitter::emitStoreActivateSint32(const SourceInfo &L) { return emitOp<>(OP_StoreActivateSint32, L); } bool ByteCodeEmitter::emitStoreActivateUint32(const SourceInfo &L) { return emitOp<>(OP_StoreActivateUint32, L); } bool ByteCodeEmitter::emitStoreActivateSint64(const SourceInfo &L) { return emitOp<>(OP_StoreActivateSint64, L); } bool ByteCodeEmitter::emitStoreActivateUint64(const SourceInfo &L) { return emitOp<>(OP_StoreActivateUint64, L); } bool ByteCodeEmitter::emitStoreActivateIntAP(const SourceInfo &L) { return emitOp<>(OP_StoreActivateIntAP, L); } bool ByteCodeEmitter::emitStoreActivateIntAPS(const SourceInfo &L) { return emitOp<>(OP_StoreActivateIntAPS, L); } bool ByteCodeEmitter::emitStoreActivateBool(const SourceInfo &L) { return emitOp<>(OP_StoreActivateBool, L); } bool ByteCodeEmitter::emitStoreActivateFixedPoint(const SourceInfo &L) { return emitOp<>(OP_StoreActivateFixedPoint, L); } bool ByteCodeEmitter::emitStoreActivatePtr(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePtr, L); } bool ByteCodeEmitter::emitStoreActivateMemberPtr(const SourceInfo &L) { return emitOp<>(OP_StoreActivateMemberPtr, L); } bool ByteCodeEmitter::emitStoreActivateFloat(const SourceInfo &L) { return emitOp<>(OP_StoreActivateFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStoreActivateSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivatePtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } bool EvalEmitter::emitStoreActivateFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivate(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StoreActivatePopSint8, OP_StoreActivatePopUint8, OP_StoreActivatePopSint16, OP_StoreActivatePopUint16, OP_StoreActivatePopSint32, OP_StoreActivatePopUint32, OP_StoreActivatePopSint64, OP_StoreActivatePopUint64, OP_StoreActivatePopIntAP, OP_StoreActivatePopIntAPS, OP_StoreActivatePopBool, OP_StoreActivatePopFixedPoint, OP_StoreActivatePopPtr, OP_StoreActivatePopMemberPtr, OP_StoreActivatePopFloat, #endif #ifdef GET_INTERP case OP_StoreActivatePopSint8: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopUint8: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopSint16: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopUint16: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopSint32: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopUint32: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopSint64: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopUint64: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopIntAP: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopIntAPS: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopBool: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopFixedPoint: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopPtr: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopMemberPtr: { if (!StoreActivatePop(S, OpPC)) return false; continue; } case OP_StoreActivatePopFloat: { if (!StoreActivatePop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StoreActivatePopSint8: Text.Op = PrintName("StoreActivatePopSint8"); break; case OP_StoreActivatePopUint8: Text.Op = PrintName("StoreActivatePopUint8"); break; case OP_StoreActivatePopSint16: Text.Op = PrintName("StoreActivatePopSint16"); break; case OP_StoreActivatePopUint16: Text.Op = PrintName("StoreActivatePopUint16"); break; case OP_StoreActivatePopSint32: Text.Op = PrintName("StoreActivatePopSint32"); break; case OP_StoreActivatePopUint32: Text.Op = PrintName("StoreActivatePopUint32"); break; case OP_StoreActivatePopSint64: Text.Op = PrintName("StoreActivatePopSint64"); break; case OP_StoreActivatePopUint64: Text.Op = PrintName("StoreActivatePopUint64"); break; case OP_StoreActivatePopIntAP: Text.Op = PrintName("StoreActivatePopIntAP"); break; case OP_StoreActivatePopIntAPS: Text.Op = PrintName("StoreActivatePopIntAPS"); break; case OP_StoreActivatePopBool: Text.Op = PrintName("StoreActivatePopBool"); break; case OP_StoreActivatePopFixedPoint: Text.Op = PrintName("StoreActivatePopFixedPoint"); break; case OP_StoreActivatePopPtr: Text.Op = PrintName("StoreActivatePopPtr"); break; case OP_StoreActivatePopMemberPtr: Text.Op = PrintName("StoreActivatePopMemberPtr"); break; case OP_StoreActivatePopFloat: Text.Op = PrintName("StoreActivatePopFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStoreActivatePopSint8(const SourceInfo &); bool emitStoreActivatePopUint8(const SourceInfo &); bool emitStoreActivatePopSint16(const SourceInfo &); bool emitStoreActivatePopUint16(const SourceInfo &); bool emitStoreActivatePopSint32(const SourceInfo &); bool emitStoreActivatePopUint32(const SourceInfo &); bool emitStoreActivatePopSint64(const SourceInfo &); bool emitStoreActivatePopUint64(const SourceInfo &); bool emitStoreActivatePopIntAP(const SourceInfo &); bool emitStoreActivatePopIntAPS(const SourceInfo &); bool emitStoreActivatePopBool(const SourceInfo &); bool emitStoreActivatePopFixedPoint(const SourceInfo &); bool emitStoreActivatePopPtr(const SourceInfo &); bool emitStoreActivatePopMemberPtr(const SourceInfo &); bool emitStoreActivatePopFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitStoreActivatePop(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitStoreActivatePop(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitStoreActivatePopSint8(I); case PT_Uint8: return emitStoreActivatePopUint8(I); case PT_Sint16: return emitStoreActivatePopSint16(I); case PT_Uint16: return emitStoreActivatePopUint16(I); case PT_Sint32: return emitStoreActivatePopSint32(I); case PT_Uint32: return emitStoreActivatePopUint32(I); case PT_Sint64: return emitStoreActivatePopSint64(I); case PT_Uint64: return emitStoreActivatePopUint64(I); case PT_IntAP: return emitStoreActivatePopIntAP(I); case PT_IntAPS: return emitStoreActivatePopIntAPS(I); case PT_Bool: return emitStoreActivatePopBool(I); case PT_FixedPoint: return emitStoreActivatePopFixedPoint(I); case PT_Ptr: return emitStoreActivatePopPtr(I); case PT_MemberPtr: return emitStoreActivatePopMemberPtr(I); case PT_Float: return emitStoreActivatePopFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStoreActivatePopSint8(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopSint8, L); } bool ByteCodeEmitter::emitStoreActivatePopUint8(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopUint8, L); } bool ByteCodeEmitter::emitStoreActivatePopSint16(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopSint16, L); } bool ByteCodeEmitter::emitStoreActivatePopUint16(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopUint16, L); } bool ByteCodeEmitter::emitStoreActivatePopSint32(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopSint32, L); } bool ByteCodeEmitter::emitStoreActivatePopUint32(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopUint32, L); } bool ByteCodeEmitter::emitStoreActivatePopSint64(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopSint64, L); } bool ByteCodeEmitter::emitStoreActivatePopUint64(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopUint64, L); } bool ByteCodeEmitter::emitStoreActivatePopIntAP(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopIntAP, L); } bool ByteCodeEmitter::emitStoreActivatePopIntAPS(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopIntAPS, L); } bool ByteCodeEmitter::emitStoreActivatePopBool(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopBool, L); } bool ByteCodeEmitter::emitStoreActivatePopFixedPoint(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopFixedPoint, L); } bool ByteCodeEmitter::emitStoreActivatePopPtr(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopPtr, L); } bool ByteCodeEmitter::emitStoreActivatePopMemberPtr(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopMemberPtr, L); } bool ByteCodeEmitter::emitStoreActivatePopFloat(const SourceInfo &L) { return emitOp<>(OP_StoreActivatePopFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStoreActivatePopSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } bool EvalEmitter::emitStoreActivatePopFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreActivatePop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StoreBitFieldSint8, OP_StoreBitFieldUint8, OP_StoreBitFieldSint16, OP_StoreBitFieldUint16, OP_StoreBitFieldSint32, OP_StoreBitFieldUint32, OP_StoreBitFieldSint64, OP_StoreBitFieldUint64, OP_StoreBitFieldIntAP, OP_StoreBitFieldIntAPS, OP_StoreBitFieldBool, OP_StoreBitFieldFixedPoint, #endif #ifdef GET_INTERP case OP_StoreBitFieldSint8: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldUint8: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldSint16: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldUint16: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldSint32: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldUint32: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldSint64: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldUint64: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldIntAP: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldIntAPS: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldBool: { if (!StoreBitField(S, OpPC)) return false; continue; } case OP_StoreBitFieldFixedPoint: { if (!StoreBitField(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StoreBitFieldSint8: Text.Op = PrintName("StoreBitFieldSint8"); break; case OP_StoreBitFieldUint8: Text.Op = PrintName("StoreBitFieldUint8"); break; case OP_StoreBitFieldSint16: Text.Op = PrintName("StoreBitFieldSint16"); break; case OP_StoreBitFieldUint16: Text.Op = PrintName("StoreBitFieldUint16"); break; case OP_StoreBitFieldSint32: Text.Op = PrintName("StoreBitFieldSint32"); break; case OP_StoreBitFieldUint32: Text.Op = PrintName("StoreBitFieldUint32"); break; case OP_StoreBitFieldSint64: Text.Op = PrintName("StoreBitFieldSint64"); break; case OP_StoreBitFieldUint64: Text.Op = PrintName("StoreBitFieldUint64"); break; case OP_StoreBitFieldIntAP: Text.Op = PrintName("StoreBitFieldIntAP"); break; case OP_StoreBitFieldIntAPS: Text.Op = PrintName("StoreBitFieldIntAPS"); break; case OP_StoreBitFieldBool: Text.Op = PrintName("StoreBitFieldBool"); break; case OP_StoreBitFieldFixedPoint: Text.Op = PrintName("StoreBitFieldFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStoreBitFieldSint8(const SourceInfo &); bool emitStoreBitFieldUint8(const SourceInfo &); bool emitStoreBitFieldSint16(const SourceInfo &); bool emitStoreBitFieldUint16(const SourceInfo &); bool emitStoreBitFieldSint32(const SourceInfo &); bool emitStoreBitFieldUint32(const SourceInfo &); bool emitStoreBitFieldSint64(const SourceInfo &); bool emitStoreBitFieldUint64(const SourceInfo &); bool emitStoreBitFieldIntAP(const SourceInfo &); bool emitStoreBitFieldIntAPS(const SourceInfo &); bool emitStoreBitFieldBool(const SourceInfo &); bool emitStoreBitFieldFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitStoreBitField(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitStoreBitField(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitStoreBitFieldSint8(I); case PT_Uint8: return emitStoreBitFieldUint8(I); case PT_Sint16: return emitStoreBitFieldSint16(I); case PT_Uint16: return emitStoreBitFieldUint16(I); case PT_Sint32: return emitStoreBitFieldSint32(I); case PT_Uint32: return emitStoreBitFieldUint32(I); case PT_Sint64: return emitStoreBitFieldSint64(I); case PT_Uint64: return emitStoreBitFieldUint64(I); case PT_IntAP: return emitStoreBitFieldIntAP(I); case PT_IntAPS: return emitStoreBitFieldIntAPS(I); case PT_Bool: return emitStoreBitFieldBool(I); case PT_FixedPoint: return emitStoreBitFieldFixedPoint(I); default: llvm_unreachable("invalid type: emitStoreBitField"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStoreBitFieldSint8(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldSint8, L); } bool ByteCodeEmitter::emitStoreBitFieldUint8(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldUint8, L); } bool ByteCodeEmitter::emitStoreBitFieldSint16(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldSint16, L); } bool ByteCodeEmitter::emitStoreBitFieldUint16(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldUint16, L); } bool ByteCodeEmitter::emitStoreBitFieldSint32(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldSint32, L); } bool ByteCodeEmitter::emitStoreBitFieldUint32(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldUint32, L); } bool ByteCodeEmitter::emitStoreBitFieldSint64(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldSint64, L); } bool ByteCodeEmitter::emitStoreBitFieldUint64(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldUint64, L); } bool ByteCodeEmitter::emitStoreBitFieldIntAP(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldIntAP, L); } bool ByteCodeEmitter::emitStoreBitFieldIntAPS(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldIntAPS, L); } bool ByteCodeEmitter::emitStoreBitFieldBool(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldBool, L); } bool ByteCodeEmitter::emitStoreBitFieldFixedPoint(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStoreBitFieldSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } bool EvalEmitter::emitStoreBitFieldFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitField(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StoreBitFieldActivateSint8, OP_StoreBitFieldActivateUint8, OP_StoreBitFieldActivateSint16, OP_StoreBitFieldActivateUint16, OP_StoreBitFieldActivateSint32, OP_StoreBitFieldActivateUint32, OP_StoreBitFieldActivateSint64, OP_StoreBitFieldActivateUint64, OP_StoreBitFieldActivateIntAP, OP_StoreBitFieldActivateIntAPS, OP_StoreBitFieldActivateBool, OP_StoreBitFieldActivateFixedPoint, #endif #ifdef GET_INTERP case OP_StoreBitFieldActivateSint8: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateUint8: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateSint16: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateUint16: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateSint32: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateUint32: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateSint64: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateUint64: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateIntAP: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateIntAPS: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateBool: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivateFixedPoint: { if (!StoreBitFieldActivate(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StoreBitFieldActivateSint8: Text.Op = PrintName("StoreBitFieldActivateSint8"); break; case OP_StoreBitFieldActivateUint8: Text.Op = PrintName("StoreBitFieldActivateUint8"); break; case OP_StoreBitFieldActivateSint16: Text.Op = PrintName("StoreBitFieldActivateSint16"); break; case OP_StoreBitFieldActivateUint16: Text.Op = PrintName("StoreBitFieldActivateUint16"); break; case OP_StoreBitFieldActivateSint32: Text.Op = PrintName("StoreBitFieldActivateSint32"); break; case OP_StoreBitFieldActivateUint32: Text.Op = PrintName("StoreBitFieldActivateUint32"); break; case OP_StoreBitFieldActivateSint64: Text.Op = PrintName("StoreBitFieldActivateSint64"); break; case OP_StoreBitFieldActivateUint64: Text.Op = PrintName("StoreBitFieldActivateUint64"); break; case OP_StoreBitFieldActivateIntAP: Text.Op = PrintName("StoreBitFieldActivateIntAP"); break; case OP_StoreBitFieldActivateIntAPS: Text.Op = PrintName("StoreBitFieldActivateIntAPS"); break; case OP_StoreBitFieldActivateBool: Text.Op = PrintName("StoreBitFieldActivateBool"); break; case OP_StoreBitFieldActivateFixedPoint: Text.Op = PrintName("StoreBitFieldActivateFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStoreBitFieldActivateSint8(const SourceInfo &); bool emitStoreBitFieldActivateUint8(const SourceInfo &); bool emitStoreBitFieldActivateSint16(const SourceInfo &); bool emitStoreBitFieldActivateUint16(const SourceInfo &); bool emitStoreBitFieldActivateSint32(const SourceInfo &); bool emitStoreBitFieldActivateUint32(const SourceInfo &); bool emitStoreBitFieldActivateSint64(const SourceInfo &); bool emitStoreBitFieldActivateUint64(const SourceInfo &); bool emitStoreBitFieldActivateIntAP(const SourceInfo &); bool emitStoreBitFieldActivateIntAPS(const SourceInfo &); bool emitStoreBitFieldActivateBool(const SourceInfo &); bool emitStoreBitFieldActivateFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitStoreBitFieldActivate(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitStoreBitFieldActivate(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitStoreBitFieldActivateSint8(I); case PT_Uint8: return emitStoreBitFieldActivateUint8(I); case PT_Sint16: return emitStoreBitFieldActivateSint16(I); case PT_Uint16: return emitStoreBitFieldActivateUint16(I); case PT_Sint32: return emitStoreBitFieldActivateSint32(I); case PT_Uint32: return emitStoreBitFieldActivateUint32(I); case PT_Sint64: return emitStoreBitFieldActivateSint64(I); case PT_Uint64: return emitStoreBitFieldActivateUint64(I); case PT_IntAP: return emitStoreBitFieldActivateIntAP(I); case PT_IntAPS: return emitStoreBitFieldActivateIntAPS(I); case PT_Bool: return emitStoreBitFieldActivateBool(I); case PT_FixedPoint: return emitStoreBitFieldActivateFixedPoint(I); default: llvm_unreachable("invalid type: emitStoreBitFieldActivate"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStoreBitFieldActivateSint8(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateSint8, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateUint8(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateUint8, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateSint16(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateSint16, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateUint16(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateUint16, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateSint32(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateSint32, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateUint32(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateUint32, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateSint64(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateSint64, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateUint64(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateUint64, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateIntAP(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateIntAP, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateIntAPS(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateIntAPS, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateBool(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateBool, L); } bool ByteCodeEmitter::emitStoreBitFieldActivateFixedPoint(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivateFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStoreBitFieldActivateSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivateFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivate(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StoreBitFieldActivatePopSint8, OP_StoreBitFieldActivatePopUint8, OP_StoreBitFieldActivatePopSint16, OP_StoreBitFieldActivatePopUint16, OP_StoreBitFieldActivatePopSint32, OP_StoreBitFieldActivatePopUint32, OP_StoreBitFieldActivatePopSint64, OP_StoreBitFieldActivatePopUint64, OP_StoreBitFieldActivatePopIntAP, OP_StoreBitFieldActivatePopIntAPS, OP_StoreBitFieldActivatePopBool, OP_StoreBitFieldActivatePopFixedPoint, #endif #ifdef GET_INTERP case OP_StoreBitFieldActivatePopSint8: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopUint8: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopSint16: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopUint16: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopSint32: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopUint32: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopSint64: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopUint64: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopIntAP: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopIntAPS: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopBool: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } case OP_StoreBitFieldActivatePopFixedPoint: { if (!StoreBitFieldActivatePop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StoreBitFieldActivatePopSint8: Text.Op = PrintName("StoreBitFieldActivatePopSint8"); break; case OP_StoreBitFieldActivatePopUint8: Text.Op = PrintName("StoreBitFieldActivatePopUint8"); break; case OP_StoreBitFieldActivatePopSint16: Text.Op = PrintName("StoreBitFieldActivatePopSint16"); break; case OP_StoreBitFieldActivatePopUint16: Text.Op = PrintName("StoreBitFieldActivatePopUint16"); break; case OP_StoreBitFieldActivatePopSint32: Text.Op = PrintName("StoreBitFieldActivatePopSint32"); break; case OP_StoreBitFieldActivatePopUint32: Text.Op = PrintName("StoreBitFieldActivatePopUint32"); break; case OP_StoreBitFieldActivatePopSint64: Text.Op = PrintName("StoreBitFieldActivatePopSint64"); break; case OP_StoreBitFieldActivatePopUint64: Text.Op = PrintName("StoreBitFieldActivatePopUint64"); break; case OP_StoreBitFieldActivatePopIntAP: Text.Op = PrintName("StoreBitFieldActivatePopIntAP"); break; case OP_StoreBitFieldActivatePopIntAPS: Text.Op = PrintName("StoreBitFieldActivatePopIntAPS"); break; case OP_StoreBitFieldActivatePopBool: Text.Op = PrintName("StoreBitFieldActivatePopBool"); break; case OP_StoreBitFieldActivatePopFixedPoint: Text.Op = PrintName("StoreBitFieldActivatePopFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStoreBitFieldActivatePopSint8(const SourceInfo &); bool emitStoreBitFieldActivatePopUint8(const SourceInfo &); bool emitStoreBitFieldActivatePopSint16(const SourceInfo &); bool emitStoreBitFieldActivatePopUint16(const SourceInfo &); bool emitStoreBitFieldActivatePopSint32(const SourceInfo &); bool emitStoreBitFieldActivatePopUint32(const SourceInfo &); bool emitStoreBitFieldActivatePopSint64(const SourceInfo &); bool emitStoreBitFieldActivatePopUint64(const SourceInfo &); bool emitStoreBitFieldActivatePopIntAP(const SourceInfo &); bool emitStoreBitFieldActivatePopIntAPS(const SourceInfo &); bool emitStoreBitFieldActivatePopBool(const SourceInfo &); bool emitStoreBitFieldActivatePopFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitStoreBitFieldActivatePop(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitStoreBitFieldActivatePop(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitStoreBitFieldActivatePopSint8(I); case PT_Uint8: return emitStoreBitFieldActivatePopUint8(I); case PT_Sint16: return emitStoreBitFieldActivatePopSint16(I); case PT_Uint16: return emitStoreBitFieldActivatePopUint16(I); case PT_Sint32: return emitStoreBitFieldActivatePopSint32(I); case PT_Uint32: return emitStoreBitFieldActivatePopUint32(I); case PT_Sint64: return emitStoreBitFieldActivatePopSint64(I); case PT_Uint64: return emitStoreBitFieldActivatePopUint64(I); case PT_IntAP: return emitStoreBitFieldActivatePopIntAP(I); case PT_IntAPS: return emitStoreBitFieldActivatePopIntAPS(I); case PT_Bool: return emitStoreBitFieldActivatePopBool(I); case PT_FixedPoint: return emitStoreBitFieldActivatePopFixedPoint(I); default: llvm_unreachable("invalid type: emitStoreBitFieldActivatePop"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint8(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopSint8, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint8(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopUint8, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint16(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopSint16, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint16(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopUint16, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint32(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopSint32, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint32(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopUint32, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint64(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopSint64, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint64(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopUint64, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopIntAP(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopIntAP, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopIntAPS(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopIntAPS, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopBool(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopBool, L); } bool ByteCodeEmitter::emitStoreBitFieldActivatePopFixedPoint(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldActivatePopFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStoreBitFieldActivatePopSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldActivatePopFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldActivatePop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StoreBitFieldPopSint8, OP_StoreBitFieldPopUint8, OP_StoreBitFieldPopSint16, OP_StoreBitFieldPopUint16, OP_StoreBitFieldPopSint32, OP_StoreBitFieldPopUint32, OP_StoreBitFieldPopSint64, OP_StoreBitFieldPopUint64, OP_StoreBitFieldPopIntAP, OP_StoreBitFieldPopIntAPS, OP_StoreBitFieldPopBool, OP_StoreBitFieldPopFixedPoint, #endif #ifdef GET_INTERP case OP_StoreBitFieldPopSint8: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopUint8: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopSint16: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopUint16: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopSint32: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopUint32: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopSint64: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopUint64: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopIntAP: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopIntAPS: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopBool: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } case OP_StoreBitFieldPopFixedPoint: { if (!StoreBitFieldPop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StoreBitFieldPopSint8: Text.Op = PrintName("StoreBitFieldPopSint8"); break; case OP_StoreBitFieldPopUint8: Text.Op = PrintName("StoreBitFieldPopUint8"); break; case OP_StoreBitFieldPopSint16: Text.Op = PrintName("StoreBitFieldPopSint16"); break; case OP_StoreBitFieldPopUint16: Text.Op = PrintName("StoreBitFieldPopUint16"); break; case OP_StoreBitFieldPopSint32: Text.Op = PrintName("StoreBitFieldPopSint32"); break; case OP_StoreBitFieldPopUint32: Text.Op = PrintName("StoreBitFieldPopUint32"); break; case OP_StoreBitFieldPopSint64: Text.Op = PrintName("StoreBitFieldPopSint64"); break; case OP_StoreBitFieldPopUint64: Text.Op = PrintName("StoreBitFieldPopUint64"); break; case OP_StoreBitFieldPopIntAP: Text.Op = PrintName("StoreBitFieldPopIntAP"); break; case OP_StoreBitFieldPopIntAPS: Text.Op = PrintName("StoreBitFieldPopIntAPS"); break; case OP_StoreBitFieldPopBool: Text.Op = PrintName("StoreBitFieldPopBool"); break; case OP_StoreBitFieldPopFixedPoint: Text.Op = PrintName("StoreBitFieldPopFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStoreBitFieldPopSint8(const SourceInfo &); bool emitStoreBitFieldPopUint8(const SourceInfo &); bool emitStoreBitFieldPopSint16(const SourceInfo &); bool emitStoreBitFieldPopUint16(const SourceInfo &); bool emitStoreBitFieldPopSint32(const SourceInfo &); bool emitStoreBitFieldPopUint32(const SourceInfo &); bool emitStoreBitFieldPopSint64(const SourceInfo &); bool emitStoreBitFieldPopUint64(const SourceInfo &); bool emitStoreBitFieldPopIntAP(const SourceInfo &); bool emitStoreBitFieldPopIntAPS(const SourceInfo &); bool emitStoreBitFieldPopBool(const SourceInfo &); bool emitStoreBitFieldPopFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitStoreBitFieldPop(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitStoreBitFieldPop(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitStoreBitFieldPopSint8(I); case PT_Uint8: return emitStoreBitFieldPopUint8(I); case PT_Sint16: return emitStoreBitFieldPopSint16(I); case PT_Uint16: return emitStoreBitFieldPopUint16(I); case PT_Sint32: return emitStoreBitFieldPopSint32(I); case PT_Uint32: return emitStoreBitFieldPopUint32(I); case PT_Sint64: return emitStoreBitFieldPopSint64(I); case PT_Uint64: return emitStoreBitFieldPopUint64(I); case PT_IntAP: return emitStoreBitFieldPopIntAP(I); case PT_IntAPS: return emitStoreBitFieldPopIntAPS(I); case PT_Bool: return emitStoreBitFieldPopBool(I); case PT_FixedPoint: return emitStoreBitFieldPopFixedPoint(I); default: llvm_unreachable("invalid type: emitStoreBitFieldPop"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStoreBitFieldPopSint8(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopSint8, L); } bool ByteCodeEmitter::emitStoreBitFieldPopUint8(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopUint8, L); } bool ByteCodeEmitter::emitStoreBitFieldPopSint16(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopSint16, L); } bool ByteCodeEmitter::emitStoreBitFieldPopUint16(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopUint16, L); } bool ByteCodeEmitter::emitStoreBitFieldPopSint32(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopSint32, L); } bool ByteCodeEmitter::emitStoreBitFieldPopUint32(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopUint32, L); } bool ByteCodeEmitter::emitStoreBitFieldPopSint64(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopSint64, L); } bool ByteCodeEmitter::emitStoreBitFieldPopUint64(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopUint64, L); } bool ByteCodeEmitter::emitStoreBitFieldPopIntAP(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopIntAP, L); } bool ByteCodeEmitter::emitStoreBitFieldPopIntAPS(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopIntAPS, L); } bool ByteCodeEmitter::emitStoreBitFieldPopBool(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopBool, L); } bool ByteCodeEmitter::emitStoreBitFieldPopFixedPoint(const SourceInfo &L) { return emitOp<>(OP_StoreBitFieldPopFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStoreBitFieldPopSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } bool EvalEmitter::emitStoreBitFieldPopFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StoreBitFieldPop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_StorePopSint8, OP_StorePopUint8, OP_StorePopSint16, OP_StorePopUint16, OP_StorePopSint32, OP_StorePopUint32, OP_StorePopSint64, OP_StorePopUint64, OP_StorePopIntAP, OP_StorePopIntAPS, OP_StorePopBool, OP_StorePopFixedPoint, OP_StorePopPtr, OP_StorePopMemberPtr, OP_StorePopFloat, #endif #ifdef GET_INTERP case OP_StorePopSint8: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopUint8: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopSint16: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopUint16: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopSint32: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopUint32: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopSint64: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopUint64: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopIntAP: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopIntAPS: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopBool: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopFixedPoint: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopPtr: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopMemberPtr: { if (!StorePop(S, OpPC)) return false; continue; } case OP_StorePopFloat: { if (!StorePop(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_StorePopSint8: Text.Op = PrintName("StorePopSint8"); break; case OP_StorePopUint8: Text.Op = PrintName("StorePopUint8"); break; case OP_StorePopSint16: Text.Op = PrintName("StorePopSint16"); break; case OP_StorePopUint16: Text.Op = PrintName("StorePopUint16"); break; case OP_StorePopSint32: Text.Op = PrintName("StorePopSint32"); break; case OP_StorePopUint32: Text.Op = PrintName("StorePopUint32"); break; case OP_StorePopSint64: Text.Op = PrintName("StorePopSint64"); break; case OP_StorePopUint64: Text.Op = PrintName("StorePopUint64"); break; case OP_StorePopIntAP: Text.Op = PrintName("StorePopIntAP"); break; case OP_StorePopIntAPS: Text.Op = PrintName("StorePopIntAPS"); break; case OP_StorePopBool: Text.Op = PrintName("StorePopBool"); break; case OP_StorePopFixedPoint: Text.Op = PrintName("StorePopFixedPoint"); break; case OP_StorePopPtr: Text.Op = PrintName("StorePopPtr"); break; case OP_StorePopMemberPtr: Text.Op = PrintName("StorePopMemberPtr"); break; case OP_StorePopFloat: Text.Op = PrintName("StorePopFloat"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitStorePopSint8(const SourceInfo &); bool emitStorePopUint8(const SourceInfo &); bool emitStorePopSint16(const SourceInfo &); bool emitStorePopUint16(const SourceInfo &); bool emitStorePopSint32(const SourceInfo &); bool emitStorePopUint32(const SourceInfo &); bool emitStorePopSint64(const SourceInfo &); bool emitStorePopUint64(const SourceInfo &); bool emitStorePopIntAP(const SourceInfo &); bool emitStorePopIntAPS(const SourceInfo &); bool emitStorePopBool(const SourceInfo &); bool emitStorePopFixedPoint(const SourceInfo &); bool emitStorePopPtr(const SourceInfo &); bool emitStorePopMemberPtr(const SourceInfo &); bool emitStorePopFloat(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitStorePop(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitStorePop(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitStorePopSint8(I); case PT_Uint8: return emitStorePopUint8(I); case PT_Sint16: return emitStorePopSint16(I); case PT_Uint16: return emitStorePopUint16(I); case PT_Sint32: return emitStorePopSint32(I); case PT_Uint32: return emitStorePopUint32(I); case PT_Sint64: return emitStorePopSint64(I); case PT_Uint64: return emitStorePopUint64(I); case PT_IntAP: return emitStorePopIntAP(I); case PT_IntAPS: return emitStorePopIntAPS(I); case PT_Bool: return emitStorePopBool(I); case PT_FixedPoint: return emitStorePopFixedPoint(I); case PT_Ptr: return emitStorePopPtr(I); case PT_MemberPtr: return emitStorePopMemberPtr(I); case PT_Float: return emitStorePopFloat(I); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitStorePopSint8(const SourceInfo &L) { return emitOp<>(OP_StorePopSint8, L); } bool ByteCodeEmitter::emitStorePopUint8(const SourceInfo &L) { return emitOp<>(OP_StorePopUint8, L); } bool ByteCodeEmitter::emitStorePopSint16(const SourceInfo &L) { return emitOp<>(OP_StorePopSint16, L); } bool ByteCodeEmitter::emitStorePopUint16(const SourceInfo &L) { return emitOp<>(OP_StorePopUint16, L); } bool ByteCodeEmitter::emitStorePopSint32(const SourceInfo &L) { return emitOp<>(OP_StorePopSint32, L); } bool ByteCodeEmitter::emitStorePopUint32(const SourceInfo &L) { return emitOp<>(OP_StorePopUint32, L); } bool ByteCodeEmitter::emitStorePopSint64(const SourceInfo &L) { return emitOp<>(OP_StorePopSint64, L); } bool ByteCodeEmitter::emitStorePopUint64(const SourceInfo &L) { return emitOp<>(OP_StorePopUint64, L); } bool ByteCodeEmitter::emitStorePopIntAP(const SourceInfo &L) { return emitOp<>(OP_StorePopIntAP, L); } bool ByteCodeEmitter::emitStorePopIntAPS(const SourceInfo &L) { return emitOp<>(OP_StorePopIntAPS, L); } bool ByteCodeEmitter::emitStorePopBool(const SourceInfo &L) { return emitOp<>(OP_StorePopBool, L); } bool ByteCodeEmitter::emitStorePopFixedPoint(const SourceInfo &L) { return emitOp<>(OP_StorePopFixedPoint, L); } bool ByteCodeEmitter::emitStorePopPtr(const SourceInfo &L) { return emitOp<>(OP_StorePopPtr, L); } bool ByteCodeEmitter::emitStorePopMemberPtr(const SourceInfo &L) { return emitOp<>(OP_StorePopMemberPtr, L); } bool ByteCodeEmitter::emitStorePopFloat(const SourceInfo &L) { return emitOp<>(OP_StorePopFloat, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitStorePopSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } bool EvalEmitter::emitStorePopFloat(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return StorePop(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_SubSint8, OP_SubUint8, OP_SubSint16, OP_SubUint16, OP_SubSint32, OP_SubUint32, OP_SubSint64, OP_SubUint64, OP_SubIntAP, OP_SubIntAPS, OP_SubBool, OP_SubFixedPoint, #endif #ifdef GET_INTERP case OP_SubSint8: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubUint8: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubSint16: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubUint16: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubSint32: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubUint32: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubSint64: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubUint64: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubIntAP: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubIntAPS: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubBool: { if (!Sub(S, OpPC)) return false; continue; } case OP_SubFixedPoint: { if (!Sub(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_SubSint8: Text.Op = PrintName("SubSint8"); break; case OP_SubUint8: Text.Op = PrintName("SubUint8"); break; case OP_SubSint16: Text.Op = PrintName("SubSint16"); break; case OP_SubUint16: Text.Op = PrintName("SubUint16"); break; case OP_SubSint32: Text.Op = PrintName("SubSint32"); break; case OP_SubUint32: Text.Op = PrintName("SubUint32"); break; case OP_SubSint64: Text.Op = PrintName("SubSint64"); break; case OP_SubUint64: Text.Op = PrintName("SubUint64"); break; case OP_SubIntAP: Text.Op = PrintName("SubIntAP"); break; case OP_SubIntAPS: Text.Op = PrintName("SubIntAPS"); break; case OP_SubBool: Text.Op = PrintName("SubBool"); break; case OP_SubFixedPoint: Text.Op = PrintName("SubFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSubSint8(const SourceInfo &); bool emitSubUint8(const SourceInfo &); bool emitSubSint16(const SourceInfo &); bool emitSubUint16(const SourceInfo &); bool emitSubSint32(const SourceInfo &); bool emitSubUint32(const SourceInfo &); bool emitSubSint64(const SourceInfo &); bool emitSubUint64(const SourceInfo &); bool emitSubIntAP(const SourceInfo &); bool emitSubIntAPS(const SourceInfo &); bool emitSubBool(const SourceInfo &); bool emitSubFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitSub(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitSub(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitSubSint8(I); case PT_Uint8: return emitSubUint8(I); case PT_Sint16: return emitSubSint16(I); case PT_Uint16: return emitSubUint16(I); case PT_Sint32: return emitSubSint32(I); case PT_Uint32: return emitSubUint32(I); case PT_Sint64: return emitSubSint64(I); case PT_Uint64: return emitSubUint64(I); case PT_IntAP: return emitSubIntAP(I); case PT_IntAPS: return emitSubIntAPS(I); case PT_Bool: return emitSubBool(I); case PT_FixedPoint: return emitSubFixedPoint(I); default: llvm_unreachable("invalid type: emitSub"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSubSint8(const SourceInfo &L) { return emitOp<>(OP_SubSint8, L); } bool ByteCodeEmitter::emitSubUint8(const SourceInfo &L) { return emitOp<>(OP_SubUint8, L); } bool ByteCodeEmitter::emitSubSint16(const SourceInfo &L) { return emitOp<>(OP_SubSint16, L); } bool ByteCodeEmitter::emitSubUint16(const SourceInfo &L) { return emitOp<>(OP_SubUint16, L); } bool ByteCodeEmitter::emitSubSint32(const SourceInfo &L) { return emitOp<>(OP_SubSint32, L); } bool ByteCodeEmitter::emitSubUint32(const SourceInfo &L) { return emitOp<>(OP_SubUint32, L); } bool ByteCodeEmitter::emitSubSint64(const SourceInfo &L) { return emitOp<>(OP_SubSint64, L); } bool ByteCodeEmitter::emitSubUint64(const SourceInfo &L) { return emitOp<>(OP_SubUint64, L); } bool ByteCodeEmitter::emitSubIntAP(const SourceInfo &L) { return emitOp<>(OP_SubIntAP, L); } bool ByteCodeEmitter::emitSubIntAPS(const SourceInfo &L) { return emitOp<>(OP_SubIntAPS, L); } bool ByteCodeEmitter::emitSubBool(const SourceInfo &L) { return emitOp<>(OP_SubBool, L); } bool ByteCodeEmitter::emitSubFixedPoint(const SourceInfo &L) { return emitOp<>(OP_SubFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSubSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } bool EvalEmitter::emitSubFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Sub(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_SubOffsetSint8, OP_SubOffsetUint8, OP_SubOffsetSint16, OP_SubOffsetUint16, OP_SubOffsetSint32, OP_SubOffsetUint32, OP_SubOffsetSint64, OP_SubOffsetUint64, OP_SubOffsetIntAP, OP_SubOffsetIntAPS, OP_SubOffsetBool, OP_SubOffsetFixedPoint, #endif #ifdef GET_INTERP case OP_SubOffsetSint8: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetUint8: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetSint16: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetUint16: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetSint32: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetUint32: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetSint64: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetUint64: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetIntAP: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetIntAPS: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetBool: { if (!SubOffset(S, OpPC)) return false; continue; } case OP_SubOffsetFixedPoint: { if (!SubOffset(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_SubOffsetSint8: Text.Op = PrintName("SubOffsetSint8"); break; case OP_SubOffsetUint8: Text.Op = PrintName("SubOffsetUint8"); break; case OP_SubOffsetSint16: Text.Op = PrintName("SubOffsetSint16"); break; case OP_SubOffsetUint16: Text.Op = PrintName("SubOffsetUint16"); break; case OP_SubOffsetSint32: Text.Op = PrintName("SubOffsetSint32"); break; case OP_SubOffsetUint32: Text.Op = PrintName("SubOffsetUint32"); break; case OP_SubOffsetSint64: Text.Op = PrintName("SubOffsetSint64"); break; case OP_SubOffsetUint64: Text.Op = PrintName("SubOffsetUint64"); break; case OP_SubOffsetIntAP: Text.Op = PrintName("SubOffsetIntAP"); break; case OP_SubOffsetIntAPS: Text.Op = PrintName("SubOffsetIntAPS"); break; case OP_SubOffsetBool: Text.Op = PrintName("SubOffsetBool"); break; case OP_SubOffsetFixedPoint: Text.Op = PrintName("SubOffsetFixedPoint"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSubOffsetSint8(const SourceInfo &); bool emitSubOffsetUint8(const SourceInfo &); bool emitSubOffsetSint16(const SourceInfo &); bool emitSubOffsetUint16(const SourceInfo &); bool emitSubOffsetSint32(const SourceInfo &); bool emitSubOffsetUint32(const SourceInfo &); bool emitSubOffsetSint64(const SourceInfo &); bool emitSubOffsetUint64(const SourceInfo &); bool emitSubOffsetIntAP(const SourceInfo &); bool emitSubOffsetIntAPS(const SourceInfo &); bool emitSubOffsetBool(const SourceInfo &); bool emitSubOffsetFixedPoint(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitSubOffset(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitSubOffset(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitSubOffsetSint8(I); case PT_Uint8: return emitSubOffsetUint8(I); case PT_Sint16: return emitSubOffsetSint16(I); case PT_Uint16: return emitSubOffsetUint16(I); case PT_Sint32: return emitSubOffsetSint32(I); case PT_Uint32: return emitSubOffsetUint32(I); case PT_Sint64: return emitSubOffsetSint64(I); case PT_Uint64: return emitSubOffsetUint64(I); case PT_IntAP: return emitSubOffsetIntAP(I); case PT_IntAPS: return emitSubOffsetIntAPS(I); case PT_Bool: return emitSubOffsetBool(I); case PT_FixedPoint: return emitSubOffsetFixedPoint(I); default: llvm_unreachable("invalid type: emitSubOffset"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSubOffsetSint8(const SourceInfo &L) { return emitOp<>(OP_SubOffsetSint8, L); } bool ByteCodeEmitter::emitSubOffsetUint8(const SourceInfo &L) { return emitOp<>(OP_SubOffsetUint8, L); } bool ByteCodeEmitter::emitSubOffsetSint16(const SourceInfo &L) { return emitOp<>(OP_SubOffsetSint16, L); } bool ByteCodeEmitter::emitSubOffsetUint16(const SourceInfo &L) { return emitOp<>(OP_SubOffsetUint16, L); } bool ByteCodeEmitter::emitSubOffsetSint32(const SourceInfo &L) { return emitOp<>(OP_SubOffsetSint32, L); } bool ByteCodeEmitter::emitSubOffsetUint32(const SourceInfo &L) { return emitOp<>(OP_SubOffsetUint32, L); } bool ByteCodeEmitter::emitSubOffsetSint64(const SourceInfo &L) { return emitOp<>(OP_SubOffsetSint64, L); } bool ByteCodeEmitter::emitSubOffsetUint64(const SourceInfo &L) { return emitOp<>(OP_SubOffsetUint64, L); } bool ByteCodeEmitter::emitSubOffsetIntAP(const SourceInfo &L) { return emitOp<>(OP_SubOffsetIntAP, L); } bool ByteCodeEmitter::emitSubOffsetIntAPS(const SourceInfo &L) { return emitOp<>(OP_SubOffsetIntAPS, L); } bool ByteCodeEmitter::emitSubOffsetBool(const SourceInfo &L) { return emitOp<>(OP_SubOffsetBool, L); } bool ByteCodeEmitter::emitSubOffsetFixedPoint(const SourceInfo &L) { return emitOp<>(OP_SubOffsetFixedPoint, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSubOffsetSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } bool EvalEmitter::emitSubOffsetFixedPoint(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubOffset(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_SubPtrSint8, OP_SubPtrUint8, OP_SubPtrSint16, OP_SubPtrUint16, OP_SubPtrSint32, OP_SubPtrUint32, OP_SubPtrSint64, OP_SubPtrUint64, OP_SubPtrIntAP, OP_SubPtrIntAPS, #endif #ifdef GET_INTERP case OP_SubPtrSint8: { if (!SubPtr(S, OpPC)) return false; continue; } case OP_SubPtrUint8: { if (!SubPtr(S, OpPC)) return false; continue; } case OP_SubPtrSint16: { if (!SubPtr(S, OpPC)) return false; continue; } case OP_SubPtrUint16: { if (!SubPtr(S, OpPC)) return false; continue; } case OP_SubPtrSint32: { if (!SubPtr(S, OpPC)) return false; continue; } case OP_SubPtrUint32: { if (!SubPtr(S, OpPC)) return false; continue; } case OP_SubPtrSint64: { if (!SubPtr(S, OpPC)) return false; continue; } case OP_SubPtrUint64: { if (!SubPtr(S, OpPC)) return false; continue; } case OP_SubPtrIntAP: { if (!SubPtr(S, OpPC)) return false; continue; } case OP_SubPtrIntAPS: { if (!SubPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_SubPtrSint8: Text.Op = PrintName("SubPtrSint8"); break; case OP_SubPtrUint8: Text.Op = PrintName("SubPtrUint8"); break; case OP_SubPtrSint16: Text.Op = PrintName("SubPtrSint16"); break; case OP_SubPtrUint16: Text.Op = PrintName("SubPtrUint16"); break; case OP_SubPtrSint32: Text.Op = PrintName("SubPtrSint32"); break; case OP_SubPtrUint32: Text.Op = PrintName("SubPtrUint32"); break; case OP_SubPtrSint64: Text.Op = PrintName("SubPtrSint64"); break; case OP_SubPtrUint64: Text.Op = PrintName("SubPtrUint64"); break; case OP_SubPtrIntAP: Text.Op = PrintName("SubPtrIntAP"); break; case OP_SubPtrIntAPS: Text.Op = PrintName("SubPtrIntAPS"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSubPtrSint8(const SourceInfo &); bool emitSubPtrUint8(const SourceInfo &); bool emitSubPtrSint16(const SourceInfo &); bool emitSubPtrUint16(const SourceInfo &); bool emitSubPtrSint32(const SourceInfo &); bool emitSubPtrUint32(const SourceInfo &); bool emitSubPtrSint64(const SourceInfo &); bool emitSubPtrUint64(const SourceInfo &); bool emitSubPtrIntAP(const SourceInfo &); bool emitSubPtrIntAPS(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitSubPtr(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitSubPtr(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitSubPtrSint8(I); case PT_Uint8: return emitSubPtrUint8(I); case PT_Sint16: return emitSubPtrSint16(I); case PT_Uint16: return emitSubPtrUint16(I); case PT_Sint32: return emitSubPtrSint32(I); case PT_Uint32: return emitSubPtrUint32(I); case PT_Sint64: return emitSubPtrSint64(I); case PT_Uint64: return emitSubPtrUint64(I); case PT_IntAP: return emitSubPtrIntAP(I); case PT_IntAPS: return emitSubPtrIntAPS(I); default: llvm_unreachable("invalid type: emitSubPtr"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSubPtrSint8(const SourceInfo &L) { return emitOp<>(OP_SubPtrSint8, L); } bool ByteCodeEmitter::emitSubPtrUint8(const SourceInfo &L) { return emitOp<>(OP_SubPtrUint8, L); } bool ByteCodeEmitter::emitSubPtrSint16(const SourceInfo &L) { return emitOp<>(OP_SubPtrSint16, L); } bool ByteCodeEmitter::emitSubPtrUint16(const SourceInfo &L) { return emitOp<>(OP_SubPtrUint16, L); } bool ByteCodeEmitter::emitSubPtrSint32(const SourceInfo &L) { return emitOp<>(OP_SubPtrSint32, L); } bool ByteCodeEmitter::emitSubPtrUint32(const SourceInfo &L) { return emitOp<>(OP_SubPtrUint32, L); } bool ByteCodeEmitter::emitSubPtrSint64(const SourceInfo &L) { return emitOp<>(OP_SubPtrSint64, L); } bool ByteCodeEmitter::emitSubPtrUint64(const SourceInfo &L) { return emitOp<>(OP_SubPtrUint64, L); } bool ByteCodeEmitter::emitSubPtrIntAP(const SourceInfo &L) { return emitOp<>(OP_SubPtrIntAP, L); } bool ByteCodeEmitter::emitSubPtrIntAPS(const SourceInfo &L) { return emitOp<>(OP_SubPtrIntAPS, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSubPtrSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } bool EvalEmitter::emitSubPtrUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } bool EvalEmitter::emitSubPtrSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } bool EvalEmitter::emitSubPtrUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } bool EvalEmitter::emitSubPtrSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } bool EvalEmitter::emitSubPtrUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } bool EvalEmitter::emitSubPtrSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } bool EvalEmitter::emitSubPtrUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } bool EvalEmitter::emitSubPtrIntAP(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } bool EvalEmitter::emitSubPtrIntAPS(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return SubPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Subf, #endif #ifdef GET_INTERP case OP_Subf: { const auto V0 = ReadArg(S, PC); if (!Subf(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_Subf: Text.Op = PrintName("Subf"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitSubf( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitSubf( uint32_t A0, const SourceInfo &L) { return emitOp(OP_Subf, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitSubf( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Subf(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_This, #endif #ifdef GET_INTERP case OP_This: { if (!This(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_This: Text.Op = PrintName("This"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitThis(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitThis(const SourceInfo &L) { return emitOp<>(OP_This, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitThis(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return This(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_ToMemberPtr, #endif #ifdef GET_INTERP case OP_ToMemberPtr: { if (!ToMemberPtr(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_ToMemberPtr: Text.Op = PrintName("ToMemberPtr"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitToMemberPtr(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitToMemberPtr(const SourceInfo &L) { return emitOp<>(OP_ToMemberPtr, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitToMemberPtr(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ToMemberPtr(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_Unsupported, #endif #ifdef GET_INTERP case OP_Unsupported: { if (!Unsupported(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_Unsupported: Text.Op = PrintName("Unsupported"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitUnsupported(const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitUnsupported(const SourceInfo &L) { return emitOp<>(OP_Unsupported, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitUnsupported(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Unsupported(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_ZeroSint8, OP_ZeroUint8, OP_ZeroSint16, OP_ZeroUint16, OP_ZeroSint32, OP_ZeroUint32, OP_ZeroSint64, OP_ZeroUint64, OP_ZeroBool, #endif #ifdef GET_INTERP case OP_ZeroSint8: { if (!Zero(S, OpPC)) return false; continue; } case OP_ZeroUint8: { if (!Zero(S, OpPC)) return false; continue; } case OP_ZeroSint16: { if (!Zero(S, OpPC)) return false; continue; } case OP_ZeroUint16: { if (!Zero(S, OpPC)) return false; continue; } case OP_ZeroSint32: { if (!Zero(S, OpPC)) return false; continue; } case OP_ZeroUint32: { if (!Zero(S, OpPC)) return false; continue; } case OP_ZeroSint64: { if (!Zero(S, OpPC)) return false; continue; } case OP_ZeroUint64: { if (!Zero(S, OpPC)) return false; continue; } case OP_ZeroBool: { if (!Zero(S, OpPC)) return false; continue; } #endif #ifdef GET_DISASM case OP_ZeroSint8: Text.Op = PrintName("ZeroSint8"); break; case OP_ZeroUint8: Text.Op = PrintName("ZeroUint8"); break; case OP_ZeroSint16: Text.Op = PrintName("ZeroSint16"); break; case OP_ZeroUint16: Text.Op = PrintName("ZeroUint16"); break; case OP_ZeroSint32: Text.Op = PrintName("ZeroSint32"); break; case OP_ZeroUint32: Text.Op = PrintName("ZeroUint32"); break; case OP_ZeroSint64: Text.Op = PrintName("ZeroSint64"); break; case OP_ZeroUint64: Text.Op = PrintName("ZeroUint64"); break; case OP_ZeroBool: Text.Op = PrintName("ZeroBool"); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitZeroSint8(const SourceInfo &); bool emitZeroUint8(const SourceInfo &); bool emitZeroSint16(const SourceInfo &); bool emitZeroUint16(const SourceInfo &); bool emitZeroSint32(const SourceInfo &); bool emitZeroUint32(const SourceInfo &); bool emitZeroSint64(const SourceInfo &); bool emitZeroUint64(const SourceInfo &); bool emitZeroBool(const SourceInfo &); #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) [[nodiscard]] bool emitZero(PrimType, const SourceInfo &I); #endif #if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL) bool #if defined(GET_EVAL_IMPL) EvalEmitter #else ByteCodeEmitter #endif ::emitZero(PrimType T0, const SourceInfo &I) { switch (T0) { case PT_Sint8: return emitZeroSint8(I); case PT_Uint8: return emitZeroUint8(I); case PT_Sint16: return emitZeroSint16(I); case PT_Uint16: return emitZeroUint16(I); case PT_Sint32: return emitZeroSint32(I); case PT_Uint32: return emitZeroUint32(I); case PT_Sint64: return emitZeroSint64(I); case PT_Uint64: return emitZeroUint64(I); case PT_Bool: return emitZeroBool(I); default: llvm_unreachable("invalid type: emitZero"); } llvm_unreachable("invalid enum value"); } #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitZeroSint8(const SourceInfo &L) { return emitOp<>(OP_ZeroSint8, L); } bool ByteCodeEmitter::emitZeroUint8(const SourceInfo &L) { return emitOp<>(OP_ZeroUint8, L); } bool ByteCodeEmitter::emitZeroSint16(const SourceInfo &L) { return emitOp<>(OP_ZeroSint16, L); } bool ByteCodeEmitter::emitZeroUint16(const SourceInfo &L) { return emitOp<>(OP_ZeroUint16, L); } bool ByteCodeEmitter::emitZeroSint32(const SourceInfo &L) { return emitOp<>(OP_ZeroSint32, L); } bool ByteCodeEmitter::emitZeroUint32(const SourceInfo &L) { return emitOp<>(OP_ZeroUint32, L); } bool ByteCodeEmitter::emitZeroSint64(const SourceInfo &L) { return emitOp<>(OP_ZeroSint64, L); } bool ByteCodeEmitter::emitZeroUint64(const SourceInfo &L) { return emitOp<>(OP_ZeroUint64, L); } bool ByteCodeEmitter::emitZeroBool(const SourceInfo &L) { return emitOp<>(OP_ZeroBool, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitZeroSint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Zero(S, OpPC); } bool EvalEmitter::emitZeroUint8(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Zero(S, OpPC); } bool EvalEmitter::emitZeroSint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Zero(S, OpPC); } bool EvalEmitter::emitZeroUint16(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Zero(S, OpPC); } bool EvalEmitter::emitZeroSint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Zero(S, OpPC); } bool EvalEmitter::emitZeroUint32(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Zero(S, OpPC); } bool EvalEmitter::emitZeroSint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Zero(S, OpPC); } bool EvalEmitter::emitZeroUint64(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Zero(S, OpPC); } bool EvalEmitter::emitZeroBool(const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return Zero(S, OpPC); } #endif #ifdef GET_OPCODE_NAMES OP_ZeroIntAP, #endif #ifdef GET_INTERP case OP_ZeroIntAP: { const auto V0 = ReadArg(S, PC); if (!ZeroIntAP(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ZeroIntAP: Text.Op = PrintName("ZeroIntAP"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitZeroIntAP( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitZeroIntAP( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ZeroIntAP, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitZeroIntAP( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ZeroIntAP(S, OpPC, A0); } #endif #ifdef GET_OPCODE_NAMES OP_ZeroIntAPS, #endif #ifdef GET_INTERP case OP_ZeroIntAPS: { const auto V0 = ReadArg(S, PC); if (!ZeroIntAPS(S, OpPC, V0)) return false; continue; } #endif #ifdef GET_DISASM case OP_ZeroIntAPS: Text.Op = PrintName("ZeroIntAPS"); Text.Args.push_back(printArg(P, PC)); break; #endif #if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO) bool emitZeroIntAPS( uint32_t , const SourceInfo &); #endif #ifdef GET_LINK_IMPL bool ByteCodeEmitter::emitZeroIntAPS( uint32_t A0, const SourceInfo &L) { return emitOp(OP_ZeroIntAPS, A0, L); } #endif #ifdef GET_EVAL_IMPL bool EvalEmitter::emitZeroIntAPS( uint32_t A0, const SourceInfo &L) { if (!isActive()) return true; CurrentSource = L; return ZeroIntAPS(S, OpPC, A0); } #endif