| //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===// |
| // |
| // The Subzero Code Generator |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements the TargetLoweringX8632 class, which |
| // consists almost entirely of the lowering sequence for each |
| // high-level instruction. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "IceTargetLoweringX8632.h" |
| |
| #include "IceTargetLoweringX8632Traits.h" |
| #include "IceTargetLoweringX86Base.h" |
| |
| namespace Ice { |
| |
| namespace X86Internal { |
| const MachineTraits<TargetX8632>::TableFcmpType |
| MachineTraits<TargetX8632>::TableFcmp[] = { |
| #define X(val, dflt, swapS, C1, C2, swapV, pred) \ |
| { \ |
| dflt, swapS, X8632::Traits::Cond::C1, X8632::Traits::Cond::C2, swapV, \ |
| X8632::Traits::Cond::pred \ |
| } \ |
| , |
| FCMPX8632_TABLE |
| #undef X |
| }; |
| |
| const size_t MachineTraits<TargetX8632>::TableFcmpSize = |
| llvm::array_lengthof(TableFcmp); |
| |
| const MachineTraits<TargetX8632>::TableIcmp32Type |
| MachineTraits<TargetX8632>::TableIcmp32[] = { |
| #define X(val, C_32, C1_64, C2_64, C3_64) \ |
| { X8632::Traits::Cond::C_32 } \ |
| , |
| ICMPX8632_TABLE |
| #undef X |
| }; |
| |
| const size_t MachineTraits<TargetX8632>::TableIcmp32Size = |
| llvm::array_lengthof(TableIcmp32); |
| |
| const MachineTraits<TargetX8632>::TableIcmp64Type |
| MachineTraits<TargetX8632>::TableIcmp64[] = { |
| #define X(val, C_32, C1_64, C2_64, C3_64) \ |
| { \ |
| X8632::Traits::Cond::C1_64, X8632::Traits::Cond::C2_64, \ |
| X8632::Traits::Cond::C3_64 \ |
| } \ |
| , |
| ICMPX8632_TABLE |
| #undef X |
| }; |
| |
| const size_t MachineTraits<TargetX8632>::TableIcmp64Size = |
| llvm::array_lengthof(TableIcmp64); |
| |
| const MachineTraits<TargetX8632>::TableTypeX8632AttributesType |
| MachineTraits<TargetX8632>::TableTypeX8632Attributes[] = { |
| #define X(tag, elementty, cvt, sdss, pack, width, fld) \ |
| { elementty } \ |
| , |
| ICETYPEX8632_TABLE |
| #undef X |
| }; |
| |
| const size_t MachineTraits<TargetX8632>::TableTypeX8632AttributesSize = |
| llvm::array_lengthof(TableTypeX8632Attributes); |
| |
| const uint32_t MachineTraits<TargetX8632>::X86_STACK_ALIGNMENT_BYTES = 16; |
| |
| } // end of namespace X86Internal |
| |
| TargetX8632 *TargetX8632::create(Cfg *Func) { |
| return X86Internal::TargetX86Base<TargetX8632>::create(Func); |
| } |
| |
| TargetDataX8632::TargetDataX8632(GlobalContext *Ctx) |
| : TargetDataLowering(Ctx) {} |
| |
| namespace { |
| template <typename T> struct PoolTypeConverter {}; |
| |
| template <> struct PoolTypeConverter<float> { |
| typedef uint32_t PrimitiveIntType; |
| typedef ConstantFloat IceType; |
| static const Type Ty = IceType_f32; |
| static const char *TypeName; |
| static const char *AsmTag; |
| static const char *PrintfString; |
| }; |
| const char *PoolTypeConverter<float>::TypeName = "float"; |
| const char *PoolTypeConverter<float>::AsmTag = ".long"; |
| const char *PoolTypeConverter<float>::PrintfString = "0x%x"; |
| |
| template <> struct PoolTypeConverter<double> { |
| typedef uint64_t PrimitiveIntType; |
| typedef ConstantDouble IceType; |
| static const Type Ty = IceType_f64; |
| static const char *TypeName; |
| static const char *AsmTag; |
| static const char *PrintfString; |
| }; |
| const char *PoolTypeConverter<double>::TypeName = "double"; |
| const char *PoolTypeConverter<double>::AsmTag = ".quad"; |
| const char *PoolTypeConverter<double>::PrintfString = "0x%llx"; |
| |
| // Add converter for int type constant pooling |
| template <> struct PoolTypeConverter<uint32_t> { |
| typedef uint32_t PrimitiveIntType; |
| typedef ConstantInteger32 IceType; |
| static const Type Ty = IceType_i32; |
| static const char *TypeName; |
| static const char *AsmTag; |
| static const char *PrintfString; |
| }; |
| const char *PoolTypeConverter<uint32_t>::TypeName = "i32"; |
| const char *PoolTypeConverter<uint32_t>::AsmTag = ".long"; |
| const char *PoolTypeConverter<uint32_t>::PrintfString = "0x%x"; |
| |
| // Add converter for int type constant pooling |
| template <> struct PoolTypeConverter<uint16_t> { |
| typedef uint32_t PrimitiveIntType; |
| typedef ConstantInteger32 IceType; |
| static const Type Ty = IceType_i16; |
| static const char *TypeName; |
| static const char *AsmTag; |
| static const char *PrintfString; |
| }; |
| const char *PoolTypeConverter<uint16_t>::TypeName = "i16"; |
| const char *PoolTypeConverter<uint16_t>::AsmTag = ".short"; |
| const char *PoolTypeConverter<uint16_t>::PrintfString = "0x%x"; |
| |
| // Add converter for int type constant pooling |
| template <> struct PoolTypeConverter<uint8_t> { |
| typedef uint32_t PrimitiveIntType; |
| typedef ConstantInteger32 IceType; |
| static const Type Ty = IceType_i8; |
| static const char *TypeName; |
| static const char *AsmTag; |
| static const char *PrintfString; |
| }; |
| const char *PoolTypeConverter<uint8_t>::TypeName = "i8"; |
| const char *PoolTypeConverter<uint8_t>::AsmTag = ".byte"; |
| const char *PoolTypeConverter<uint8_t>::PrintfString = "0x%x"; |
| } // end of anonymous namespace |
| |
| template <typename T> |
| void TargetDataX8632::emitConstantPool(GlobalContext *Ctx) { |
| if (!BuildDefs::dump()) |
| return; |
| Ostream &Str = Ctx->getStrEmit(); |
| Type Ty = T::Ty; |
| SizeT Align = typeAlignInBytes(Ty); |
| ConstantList Pool = Ctx->getConstantPool(Ty); |
| |
| Str << "\t.section\t.rodata.cst" << Align << ",\"aM\",@progbits," << Align |
| << "\n"; |
| Str << "\t.align\t" << Align << "\n"; |
| |
| // If reorder-pooled-constants option is set to true, we need to shuffle the |
| // constant pool before emitting it. |
| if (Ctx->getFlags().shouldReorderPooledConstants()) |
| RandomShuffle(Pool.begin(), Pool.end(), [Ctx](uint64_t N) { |
| return (uint32_t)Ctx->getRNG().next(N); |
| }); |
| |
| for (Constant *C : Pool) { |
| if (!C->getShouldBePooled()) |
| continue; |
| typename T::IceType *Const = llvm::cast<typename T::IceType>(C); |
| typename T::IceType::PrimType Value = Const->getValue(); |
| // Use memcpy() to copy bits from Value into RawValue in a way |
| // that avoids breaking strict-aliasing rules. |
| typename T::PrimitiveIntType RawValue; |
| memcpy(&RawValue, &Value, sizeof(Value)); |
| char buf[30]; |
| int CharsPrinted = |
| snprintf(buf, llvm::array_lengthof(buf), T::PrintfString, RawValue); |
| assert(CharsPrinted >= 0 && |
| (size_t)CharsPrinted < llvm::array_lengthof(buf)); |
| (void)CharsPrinted; // avoid warnings if asserts are disabled |
| Const->emitPoolLabel(Str); |
| Str << ":\n\t" << T::AsmTag << "\t" << buf << "\t# " << T::TypeName << " " |
| << Value << "\n"; |
| } |
| } |
| |
| void TargetDataX8632::lowerConstants() { |
| if (Ctx->getFlags().getDisableTranslation()) |
| return; |
| // No need to emit constants from the int pool since (for x86) they |
| // are embedded as immediates in the instructions, just emit float/double. |
| switch (Ctx->getFlags().getOutFileType()) { |
| case FT_Elf: { |
| ELFObjectWriter *Writer = Ctx->getObjectWriter(); |
| |
| Writer->writeConstantPool<ConstantInteger32>(IceType_i8); |
| Writer->writeConstantPool<ConstantInteger32>(IceType_i16); |
| Writer->writeConstantPool<ConstantInteger32>(IceType_i32); |
| |
| Writer->writeConstantPool<ConstantFloat>(IceType_f32); |
| Writer->writeConstantPool<ConstantDouble>(IceType_f64); |
| } break; |
| case FT_Asm: |
| case FT_Iasm: { |
| OstreamLocker L(Ctx); |
| |
| emitConstantPool<PoolTypeConverter<uint8_t>>(Ctx); |
| emitConstantPool<PoolTypeConverter<uint16_t>>(Ctx); |
| emitConstantPool<PoolTypeConverter<uint32_t>>(Ctx); |
| |
| emitConstantPool<PoolTypeConverter<float>>(Ctx); |
| emitConstantPool<PoolTypeConverter<double>>(Ctx); |
| } break; |
| } |
| } |
| |
| void TargetDataX8632::lowerGlobals(const VariableDeclarationList &Vars, |
| const IceString &SectionSuffix) { |
| switch (Ctx->getFlags().getOutFileType()) { |
| case FT_Elf: { |
| ELFObjectWriter *Writer = Ctx->getObjectWriter(); |
| Writer->writeDataSection(Vars, llvm::ELF::R_386_32, SectionSuffix); |
| } break; |
| case FT_Asm: |
| case FT_Iasm: { |
| const IceString &TranslateOnly = Ctx->getFlags().getTranslateOnly(); |
| OstreamLocker L(Ctx); |
| for (const VariableDeclaration *Var : Vars) { |
| if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) { |
| emitGlobal(*Var, SectionSuffix); |
| } |
| } |
| } break; |
| } |
| } |
| |
| TargetHeaderX8632::TargetHeaderX8632(GlobalContext *Ctx) |
| : TargetHeaderLowering(Ctx) {} |
| |
| // In some cases, there are x-macros tables for both high-level and |
| // low-level instructions/operands that use the same enum key value. |
| // The tables are kept separate to maintain a proper separation |
| // between abstraction layers. There is a risk that the tables could |
| // get out of sync if enum values are reordered or if entries are |
| // added or deleted. The following dummy namespaces use |
| // static_asserts to ensure everything is kept in sync. |
| |
| namespace { |
| // Validate the enum values in FCMPX8632_TABLE. |
| namespace dummy1 { |
| // Define a temporary set of enum values based on low-level table |
| // entries. |
| enum _tmp_enum { |
| #define X(val, dflt, swapS, C1, C2, swapV, pred) _tmp_##val, |
| FCMPX8632_TABLE |
| #undef X |
| _num |
| }; |
| // Define a set of constants based on high-level table entries. |
| #define X(tag, str) static const int _table1_##tag = InstFcmp::tag; |
| ICEINSTFCMP_TABLE |
| #undef X |
| // Define a set of constants based on low-level table entries, and |
| // ensure the table entry keys are consistent. |
| #define X(val, dflt, swapS, C1, C2, swapV, pred) \ |
| static const int _table2_##val = _tmp_##val; \ |
| static_assert( \ |
| _table1_##val == _table2_##val, \ |
| "Inconsistency between FCMPX8632_TABLE and ICEINSTFCMP_TABLE"); |
| FCMPX8632_TABLE |
| #undef X |
| // Repeat the static asserts with respect to the high-level table |
| // entries in case the high-level table has extra entries. |
| #define X(tag, str) \ |
| static_assert( \ |
| _table1_##tag == _table2_##tag, \ |
| "Inconsistency between FCMPX8632_TABLE and ICEINSTFCMP_TABLE"); |
| ICEINSTFCMP_TABLE |
| #undef X |
| } // end of namespace dummy1 |
| |
| // Validate the enum values in ICMPX8632_TABLE. |
| namespace dummy2 { |
| // Define a temporary set of enum values based on low-level table |
| // entries. |
| enum _tmp_enum { |
| #define X(val, C_32, C1_64, C2_64, C3_64) _tmp_##val, |
| ICMPX8632_TABLE |
| #undef X |
| _num |
| }; |
| // Define a set of constants based on high-level table entries. |
| #define X(tag, str) static const int _table1_##tag = InstIcmp::tag; |
| ICEINSTICMP_TABLE |
| #undef X |
| // Define a set of constants based on low-level table entries, and |
| // ensure the table entry keys are consistent. |
| #define X(val, C_32, C1_64, C2_64, C3_64) \ |
| static const int _table2_##val = _tmp_##val; \ |
| static_assert( \ |
| _table1_##val == _table2_##val, \ |
| "Inconsistency between ICMPX8632_TABLE and ICEINSTICMP_TABLE"); |
| ICMPX8632_TABLE |
| #undef X |
| // Repeat the static asserts with respect to the high-level table |
| // entries in case the high-level table has extra entries. |
| #define X(tag, str) \ |
| static_assert( \ |
| _table1_##tag == _table2_##tag, \ |
| "Inconsistency between ICMPX8632_TABLE and ICEINSTICMP_TABLE"); |
| ICEINSTICMP_TABLE |
| #undef X |
| } // end of namespace dummy2 |
| |
| // Validate the enum values in ICETYPEX8632_TABLE. |
| namespace dummy3 { |
| // Define a temporary set of enum values based on low-level table |
| // entries. |
| enum _tmp_enum { |
| #define X(tag, elementty, cvt, sdss, pack, width, fld) _tmp_##tag, |
| ICETYPEX8632_TABLE |
| #undef X |
| _num |
| }; |
| // Define a set of constants based on high-level table entries. |
| #define X(tag, size, align, elts, elty, str) \ |
| static const int _table1_##tag = tag; |
| ICETYPE_TABLE |
| #undef X |
| // Define a set of constants based on low-level table entries, and |
| // ensure the table entry keys are consistent. |
| #define X(tag, elementty, cvt, sdss, pack, width, fld) \ |
| static const int _table2_##tag = _tmp_##tag; \ |
| static_assert(_table1_##tag == _table2_##tag, \ |
| "Inconsistency between ICETYPEX8632_TABLE and ICETYPE_TABLE"); |
| ICETYPEX8632_TABLE |
| #undef X |
| // Repeat the static asserts with respect to the high-level table |
| // entries in case the high-level table has extra entries. |
| #define X(tag, size, align, elts, elty, str) \ |
| static_assert(_table1_##tag == _table2_##tag, \ |
| "Inconsistency between ICETYPEX8632_TABLE and ICETYPE_TABLE"); |
| ICETYPE_TABLE |
| #undef X |
| } // end of namespace dummy3 |
| } // end of anonymous namespace |
| |
| } // end of namespace Ice |