From 99b11484d9c0dea9d010d0a37bacc82a11972617 Mon Sep 17 00:00:00 2001 From: Micah Villmow Date: Thu, 4 Oct 2012 23:01:22 +0000 Subject: [PATCH] Rename the Target specific passes in the DataLayout class to be Target agnostic. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165270 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/DataLayout.h | 71 ++++++++++++------------ include/llvm/InitializePasses.h | 1 + lib/VMCore/DataLayout.cpp | 96 ++++++++++++++++----------------- 3 files changed, 85 insertions(+), 83 deletions(-) diff --git a/include/llvm/DataLayout.h b/include/llvm/DataLayout.h index 71dec67779d..609594d20af 100644 --- a/include/llvm/DataLayout.h +++ b/include/llvm/DataLayout.h @@ -1,4 +1,4 @@ -//===-- llvm/Target/TargetData.h - Data size & alignment info ---*- C++ -*-===// +//===--------- llvm/DataLayout.h - Data size & alignment info ---*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file defines target properties related to datatype size/offset/alignment +// This file defines layout properties related to datatype size/offset/alignment // information. It uses lazy annotations to cache information about how // structure types are laid out and used. // @@ -17,8 +17,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_TARGET_TARGETDATA_H -#define LLVM_TARGET_TARGETDATA_H +#ifndef LLVM_DATALAYOUT_H +#define LLVM_DATALAYOUT_H #include "llvm/Pass.h" #include "llvm/ADT/SmallVector.h" @@ -36,7 +36,7 @@ class LLVMContext; template class ArrayRef; -/// Enum used to categorize the alignment types stored by TargetAlignElem +/// Enum used to categorize the alignment types stored by LayoutAlignElem enum AlignTypeEnum { INTEGER_ALIGN = 'i', ///< Integer type alignment VECTOR_ALIGN = 'v', ///< Vector type alignment @@ -45,33 +45,33 @@ enum AlignTypeEnum { STACK_ALIGN = 's' ///< Stack objects alignment }; -/// Target alignment element. +/// Layout alignment element. /// /// Stores the alignment data associated with a given alignment type (pointer, /// integer, vector, float) and type bit width. /// /// @note The unusual order of elements in the structure attempts to reduce /// padding and make the structure slightly more cache friendly. -struct TargetAlignElem { +struct LayoutAlignElem { unsigned AlignType : 8; ///< Alignment type (AlignTypeEnum) unsigned TypeBitWidth : 24; ///< Type bit width unsigned ABIAlign : 16; ///< ABI alignment for this type/bitw unsigned PrefAlign : 16; ///< Pref. alignment for this type/bitw /// Initializer - static TargetAlignElem get(AlignTypeEnum align_type, unsigned abi_align, + static LayoutAlignElem get(AlignTypeEnum align_type, unsigned abi_align, unsigned pref_align, uint32_t bit_width); /// Equality predicate - bool operator==(const TargetAlignElem &rhs) const; + bool operator==(const LayoutAlignElem &rhs) const; }; -/// TargetData - This class holds a parsed version of the target data layout +/// DataLayout - This class holds a parsed version of the target data layout /// string in a module and provides methods for querying it. The target data /// layout string is specified *by the target* - a frontend generating LLVM IR /// is required to generate the right target data for the target being codegen'd /// to. If some measure of portability is desired, an empty string may be /// specified in the module. -class TargetData : public ImmutablePass { +class DataLayout : public ImmutablePass { private: bool LittleEndian; ///< Defaults to false unsigned PointerMemSize; ///< Pointer size in bytes @@ -85,13 +85,13 @@ private: /// /// @sa init(). /// @note Could support multiple size pointer alignments, e.g., 32-bit - /// pointers vs. 64-bit pointers by extending TargetAlignment, but for now, + /// pointers vs. 64-bit pointers by extending LayoutAlignment, but for now, /// we don't. - SmallVector Alignments; + SmallVector Alignments; /// InvalidAlignmentElem - This member is a signal that a requested alignment /// type and bit width were not found in the SmallVector. - static const TargetAlignElem InvalidAlignmentElem; + static const LayoutAlignElem InvalidAlignmentElem; // The StructType -> StructLayout map. mutable void *LayoutMap; @@ -106,13 +106,13 @@ private: /// Valid alignment predicate. /// - /// Predicate that tests a TargetAlignElem reference returned by get() against + /// Predicate that tests a LayoutAlignElem reference returned by get() against /// InvalidAlignmentElem. - bool validAlignment(const TargetAlignElem &align) const { + bool validAlignment(const LayoutAlignElem &align) const { return &align != &InvalidAlignmentElem; } - /// Initialise a TargetData object with default values, ensure that the + /// Initialise a DataLayout object with default values, ensure that the /// target data pass is registered. void init(); @@ -121,25 +121,26 @@ public: /// /// @note This has to exist, because this is a pass, but it should never be /// used. - TargetData(); + DataLayout(); - /// Constructs a TargetData from a specification string. See init(). - explicit TargetData(StringRef TargetDescription) + /// Constructs a DataLayout from a specification string. See init(). + explicit DataLayout(StringRef LayoutDescription) : ImmutablePass(ID) { - std::string errMsg = parseSpecifier(TargetDescription, this); + std::string errMsg = parseSpecifier(LayoutDescription, this); assert(errMsg == "" && "Invalid target data layout string."); (void)errMsg; } /// Parses a target data specification string. Returns an error message /// if the string is malformed, or the empty string on success. Optionally - /// initialises a TargetData object if passed a non-null pointer. - static std::string parseSpecifier(StringRef TargetDescription, TargetData* td = 0); + /// initialises a DataLayout object if passed a non-null pointer. + static std::string parseSpecifier(StringRef LayoutDescription, + DataLayout* td = 0); /// Initialize target data from properties stored in the module. - explicit TargetData(const Module *M); + explicit DataLayout(const Module *M); - TargetData(const TargetData &TD) : + DataLayout(const DataLayout &TD) : ImmutablePass(ID), LittleEndian(TD.isLittleEndian()), PointerMemSize(TD.PointerMemSize), @@ -150,14 +151,14 @@ public: LayoutMap(0) { } - ~TargetData(); // Not virtual, do not subclass this class + ~DataLayout(); // Not virtual, do not subclass this class - /// Target endianness... + /// Layout endianness... bool isLittleEndian() const { return LittleEndian; } bool isBigEndian() const { return !LittleEndian; } /// getStringRepresentation - Return the string representation of the - /// TargetData. This representation is in the same format accepted by the + /// DataLayout. This representation is in the same format accepted by the /// string constructor above. std::string getStringRepresentation() const; @@ -195,13 +196,13 @@ public: return false; } - /// Target pointer alignment + /// Layout pointer alignment unsigned getPointerABIAlignment() const { return PointerABIAlign; } - /// Return target's alignment for stack-based pointers + /// Return layout's alignment for stack-based pointers unsigned getPointerPrefAlignment() const { return PointerPrefAlign; } - /// Target pointer size + /// Layout pointer size unsigned getPointerSize() const { return PointerMemSize; } - /// Target pointer size, in bits + /// Layout pointer size, in bits unsigned getPointerSizeInBits() const { return 8*PointerMemSize; } /// Size examples: @@ -318,7 +319,7 @@ public: }; /// StructLayout - used to lazily calculate structure layout information for a -/// target machine, based on the TargetData structure. +/// target machine, based on the DataLayout structure. /// class StructLayout { uint64_t StructSize; @@ -354,8 +355,8 @@ public: } private: - friend class TargetData; // Only TargetData can create this class - StructLayout(StructType *ST, const TargetData &TD); + friend class DataLayout; // Only DataLayout can create this class + StructLayout(StructType *ST, const DataLayout &TD); }; } // End llvm namespace diff --git a/include/llvm/InitializePasses.h b/include/llvm/InitializePasses.h index 76c22b0fb8f..872a8802446 100644 --- a/include/llvm/InitializePasses.h +++ b/include/llvm/InitializePasses.h @@ -247,6 +247,7 @@ void initializeTailCallElimPass(PassRegistry&); void initializeTailDuplicatePassPass(PassRegistry&); void initializeTargetPassConfigPass(PassRegistry&); void initializeTargetDataPass(PassRegistry&); +void initializeDataLayoutPass(PassRegistry&); void initializeTargetLibraryInfoPass(PassRegistry&); void initializeTwoAddressInstructionPassPass(PassRegistry&); void initializeTypeBasedAliasAnalysisPass(PassRegistry&); diff --git a/lib/VMCore/DataLayout.cpp b/lib/VMCore/DataLayout.cpp index 0040147022d..075350c554e 100644 --- a/lib/VMCore/DataLayout.cpp +++ b/lib/VMCore/DataLayout.cpp @@ -1,4 +1,4 @@ -//===-- TargetData.cpp - Data size & alignment routines --------------------==// +//===-- DataLayout.cpp - Data size & alignment routines --------------------==// // // The LLVM Compiler Infrastructure // @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file defines target properties related to datatype size/offset/alignment +// This file defines layout properties related to datatype size/offset/alignment // information. // // This structure should be created once, filled in if the defaults are not @@ -16,7 +16,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Target/TargetData.h" +#include "llvm/DataLayout.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/Module.h" @@ -31,17 +31,17 @@ #include using namespace llvm; -// Handle the Pass registration stuff necessary to use TargetData's. +// Handle the Pass registration stuff necessary to use DataLayout's. // Register the default SparcV9 implementation... -INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true) -char TargetData::ID = 0; +INITIALIZE_PASS(DataLayout, "datalayout", "Data Layout", false, true) +char DataLayout::ID = 0; //===----------------------------------------------------------------------===// // Support for StructLayout //===----------------------------------------------------------------------===// -StructLayout::StructLayout(StructType *ST, const TargetData &TD) { +StructLayout::StructLayout(StructType *ST, const DataLayout &TD) { assert(!ST->isOpaque() && "Cannot get layout of opaque structs"); StructAlignment = 0; StructSize = 0; @@ -54,7 +54,7 @@ StructLayout::StructLayout(StructType *ST, const TargetData &TD) { // Add padding if necessary to align the data element properly. if ((StructSize & (TyAlign-1)) != 0) - StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign); + StructSize = DataLayout::RoundUpAlignment(StructSize, TyAlign); // Keep track of maximum alignment constraint. StructAlignment = std::max(TyAlign, StructAlignment); @@ -69,7 +69,7 @@ StructLayout::StructLayout(StructType *ST, const TargetData &TD) { // Add padding to the end of the struct so that it could be put in an array // and all array elements would be aligned correctly. if ((StructSize & (StructAlignment-1)) != 0) - StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment); + StructSize = DataLayout::RoundUpAlignment(StructSize, StructAlignment); } @@ -94,14 +94,14 @@ unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const { } //===----------------------------------------------------------------------===// -// TargetAlignElem, TargetAlign support +// LayoutAlignElem, LayoutAlign support //===----------------------------------------------------------------------===// -TargetAlignElem -TargetAlignElem::get(AlignTypeEnum align_type, unsigned abi_align, +LayoutAlignElem +LayoutAlignElem::get(AlignTypeEnum align_type, unsigned abi_align, unsigned pref_align, uint32_t bit_width) { assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); - TargetAlignElem retval; + LayoutAlignElem retval; retval.AlignType = align_type; retval.ABIAlign = abi_align; retval.PrefAlign = pref_align; @@ -110,18 +110,18 @@ TargetAlignElem::get(AlignTypeEnum align_type, unsigned abi_align, } bool -TargetAlignElem::operator==(const TargetAlignElem &rhs) const { +LayoutAlignElem::operator==(const LayoutAlignElem &rhs) const { return (AlignType == rhs.AlignType && ABIAlign == rhs.ABIAlign && PrefAlign == rhs.PrefAlign && TypeBitWidth == rhs.TypeBitWidth); } -const TargetAlignElem -TargetData::InvalidAlignmentElem = { (AlignTypeEnum)0xFF, 0, 0, 0 }; +const LayoutAlignElem +DataLayout::InvalidAlignmentElem = { (AlignTypeEnum)0xFF, 0, 0, 0 }; //===----------------------------------------------------------------------===// -// TargetData Class Implementation +// DataLayout Class Implementation //===----------------------------------------------------------------------===// /// getInt - Get an integer ignoring errors. @@ -131,8 +131,8 @@ static int getInt(StringRef R) { return Result; } -void TargetData::init() { - initializeTargetDataPass(*PassRegistry::getPassRegistry()); +void DataLayout::init() { + initializeDataLayoutPass(*PassRegistry::getPassRegistry()); LayoutMap = 0; LittleEndian = false; @@ -156,7 +156,7 @@ void TargetData::init() { setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct } -std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) { +std::string DataLayout::parseSpecifier(StringRef Desc, DataLayout *td) { if (td) td->init(); @@ -256,7 +256,7 @@ std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) { unsigned PrefAlign = PrefAlignBits / 8; if (PrefAlign == 0) PrefAlign = ABIAlign; - + if (td) td->setAlignment(AlignType, ABIAlign, PrefAlign, Size); break; @@ -266,8 +266,8 @@ std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) { do { int Width = getInt(Specifier); if (Width <= 0) { - return std::string("invalid native integer size \'") + Specifier.str() + - "\', must be a positive integer."; + return std::string("invalid native integer size \'") + + Specifier.str() + "\', must be a positive integer."; } if (td && Width != 0) td->LegalIntWidths.push_back(Width); @@ -298,20 +298,20 @@ std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) { /// /// @note This has to exist, because this is a pass, but it should never be /// used. -TargetData::TargetData() : ImmutablePass(ID) { - report_fatal_error("Bad TargetData ctor used. " - "Tool did not specify a TargetData to use?"); +DataLayout::DataLayout() : ImmutablePass(ID) { + report_fatal_error("Bad DataLayout ctor used. " + "Tool did not specify a DataLayout to use?"); } -TargetData::TargetData(const Module *M) +DataLayout::DataLayout(const Module *M) : ImmutablePass(ID) { std::string errMsg = parseSpecifier(M->getDataLayout(), this); - assert(errMsg == "" && "Module M has malformed target data layout string."); + assert(errMsg == "" && "Module M has malformed data layout string."); (void)errMsg; } void -TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align, +DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align, unsigned pref_align, uint32_t bit_width) { assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); assert(pref_align < (1 << 16) && "Alignment doesn't fit in bitfield"); @@ -326,13 +326,13 @@ TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align, } } - Alignments.push_back(TargetAlignElem::get(align_type, abi_align, + Alignments.push_back(LayoutAlignElem::get(align_type, abi_align, pref_align, bit_width)); } /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or -/// preferred if ABIInfo = false) the target wants for the specified datatype. -unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType, +/// preferred if ABIInfo = false) the layout wants for the specified datatype. +unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType, uint32_t BitWidth, bool ABIInfo, Type *Ty) const { // Check to see if we have an exact match and remember the best match we see. @@ -412,11 +412,11 @@ public: } // end anonymous namespace -TargetData::~TargetData() { +DataLayout::~DataLayout() { delete static_cast(LayoutMap); } -const StructLayout *TargetData::getStructLayout(StructType *Ty) const { +const StructLayout *DataLayout::getStructLayout(StructType *Ty) const { if (!LayoutMap) LayoutMap = new StructLayoutMap(); @@ -439,7 +439,7 @@ const StructLayout *TargetData::getStructLayout(StructType *Ty) const { return L; } -std::string TargetData::getStringRepresentation() const { +std::string DataLayout::getStringRepresentation() const { std::string Result; raw_string_ostream OS(Result); @@ -449,7 +449,7 @@ std::string TargetData::getStringRepresentation() const { << "-S" << StackNaturalAlign*8; for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { - const TargetAlignElem &AI = Alignments[i]; + const LayoutAlignElem &AI = Alignments[i]; OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':' << AI.ABIAlign*8 << ':' << AI.PrefAlign*8; } @@ -464,7 +464,7 @@ std::string TargetData::getStringRepresentation() const { } -uint64_t TargetData::getTypeSizeInBits(Type *Ty) const { +uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const { assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); switch (Ty->getTypeID()) { case Type::LabelTyID: @@ -498,7 +498,7 @@ uint64_t TargetData::getTypeSizeInBits(Type *Ty) const { case Type::VectorTyID: return cast(Ty)->getBitWidth(); default: - llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type"); + llvm_unreachable("DataLayout::getTypeSizeInBits(): Unsupported type"); } } @@ -510,7 +510,7 @@ uint64_t TargetData::getTypeSizeInBits(Type *Ty) const { Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref == false) for the requested type \a Ty. */ -unsigned TargetData::getAlignment(Type *Ty, bool abi_or_pref) const { +unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const { int AlignType = -1; assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); @@ -560,18 +560,18 @@ unsigned TargetData::getAlignment(Type *Ty, bool abi_or_pref) const { abi_or_pref, Ty); } -unsigned TargetData::getABITypeAlignment(Type *Ty) const { +unsigned DataLayout::getABITypeAlignment(Type *Ty) const { return getAlignment(Ty, true); } /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for /// an integer type of the specified bitwidth. -unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const { +unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const { return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0); } -unsigned TargetData::getCallFrameTypeAlignment(Type *Ty) const { +unsigned DataLayout::getCallFrameTypeAlignment(Type *Ty) const { for (unsigned i = 0, e = Alignments.size(); i != e; ++i) if (Alignments[i].AlignType == STACK_ALIGN) return Alignments[i].ABIAlign; @@ -579,11 +579,11 @@ unsigned TargetData::getCallFrameTypeAlignment(Type *Ty) const { return getABITypeAlignment(Ty); } -unsigned TargetData::getPrefTypeAlignment(Type *Ty) const { +unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const { return getAlignment(Ty, false); } -unsigned TargetData::getPreferredTypeAlignmentShift(Type *Ty) const { +unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const { unsigned Align = getPrefTypeAlignment(Ty); assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); return Log2_32(Align); @@ -591,12 +591,12 @@ unsigned TargetData::getPreferredTypeAlignmentShift(Type *Ty) const { /// getIntPtrType - Return an unsigned integer type that is the same size or /// greater to the host pointer size. -IntegerType *TargetData::getIntPtrType(LLVMContext &C) const { +IntegerType *DataLayout::getIntPtrType(LLVMContext &C) const { return IntegerType::get(C, getPointerSizeInBits()); } -uint64_t TargetData::getIndexedOffset(Type *ptrTy, +uint64_t DataLayout::getIndexedOffset(Type *ptrTy, ArrayRef Indices) const { Type *Ty = ptrTy; assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()"); @@ -636,7 +636,7 @@ uint64_t TargetData::getIndexedOffset(Type *ptrTy, /// getPreferredAlignment - Return the preferred alignment of the specified /// global. This includes an explicitly requested alignment (if the global /// has one). -unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const { +unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const { Type *ElemType = GV->getType()->getElementType(); unsigned Alignment = getPrefTypeAlignment(ElemType); unsigned GVAlignment = GV->getAlignment(); @@ -660,6 +660,6 @@ unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const { /// getPreferredAlignmentLog - Return the preferred alignment of the /// specified global, returned in log form. This includes an explicitly /// requested alignment (if the global has one). -unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const { +unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const { return Log2_32(getPreferredAlignment(GV)); } -- 2.34.1