RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity

Rename the Target specific passes in the DataLayout class to be Target agnostic.

Browse Source 
llvm-svn: 165270
This commit is contained in:
Micah Villmow 2012-10-04 23:01:22 +00:00
parent 2f513f5a29
commit 3570de6384
3 changed files with 85 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
include/llvm/DataLayout.h
View File

@ -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 // 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 // information. It uses lazy annotations to cache information about how
// structure types are laid out and used. // structure types are laid out and used.
// //
@ -17,8 +17,8 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_TARGET_TARGETDATA_H #ifndef LLVM_DATALAYOUT_H
#define LLVM_TARGET_TARGETDATA_H #define LLVM_DATALAYOUT_H
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
@ -36,7 +36,7 @@ class LLVMContext;
template<typename T> template<typename T>
class ArrayRef; class ArrayRef;
/// Enum used to categorize the alignment types stored by TargetAlignElem /// Enum used to categorize the alignment types stored by LayoutAlignElem
enum AlignTypeEnum { enum AlignTypeEnum {
INTEGER_ALIGN = 'i', ///< Integer type alignment INTEGER_ALIGN = 'i', ///< Integer type alignment
VECTOR_ALIGN = 'v', ///< Vector type alignment VECTOR_ALIGN = 'v', ///< Vector type alignment
@ -45,33 +45,33 @@ enum AlignTypeEnum {
STACK_ALIGN = 's' ///< Stack objects alignment STACK_ALIGN = 's' ///< Stack objects alignment
}; };
/// Target alignment element. /// Layout alignment element.
/// ///
/// Stores the alignment data associated with a given alignment type (pointer, /// Stores the alignment data associated with a given alignment type (pointer,
/// integer, vector, float) and type bit width. /// integer, vector, float) and type bit width.
/// ///
/// @note The unusual order of elements in the structure attempts to reduce /// @note The unusual order of elements in the structure attempts to reduce
/// padding and make the structure slightly more cache friendly. /// padding and make the structure slightly more cache friendly.
struct TargetAlignElem { struct LayoutAlignElem {
unsigned AlignType : 8; ///< Alignment type (AlignTypeEnum) unsigned AlignType : 8; ///< Alignment type (AlignTypeEnum)
unsigned TypeBitWidth : 24; ///< Type bit width unsigned TypeBitWidth : 24; ///< Type bit width
unsigned ABIAlign : 16; ///< ABI alignment for this type/bitw unsigned ABIAlign : 16; ///< ABI alignment for this type/bitw
unsigned PrefAlign : 16; ///< Pref. alignment for this type/bitw unsigned PrefAlign : 16; ///< Pref. alignment for this type/bitw
/// Initializer /// 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); unsigned pref_align, uint32_t bit_width);
/// Equality predicate /// 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 /// 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 /// 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 /// 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 /// to. If some measure of portability is desired, an empty string may be
/// specified in the module. /// specified in the module.
class TargetData : public ImmutablePass { class DataLayout : public ImmutablePass {
private: private:
bool LittleEndian; ///< Defaults to false bool LittleEndian; ///< Defaults to false
unsigned PointerMemSize; ///< Pointer size in bytes unsigned PointerMemSize; ///< Pointer size in bytes
@ -85,13 +85,13 @@ private:
/// ///
/// @sa init(). /// @sa init().
/// @note Could support multiple size pointer alignments, e.g., 32-bit /// @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. /// we don't.
SmallVector<TargetAlignElem, 16> Alignments; SmallVector<LayoutAlignElem, 16> Alignments;
/// InvalidAlignmentElem - This member is a signal that a requested alignment /// InvalidAlignmentElem - This member is a signal that a requested alignment
/// type and bit width were not found in the SmallVector. /// type and bit width were not found in the SmallVector.
static const TargetAlignElem InvalidAlignmentElem; static const LayoutAlignElem InvalidAlignmentElem;
// The StructType -> StructLayout map. // The StructType -> StructLayout map.
mutable void *LayoutMap; mutable void *LayoutMap;
@ -106,13 +106,13 @@ private:
/// Valid alignment predicate. /// Valid alignment predicate.
/// ///
/// Predicate that tests a TargetAlignElem reference returned by get() against /// Predicate that tests a LayoutAlignElem reference returned by get() against
/// InvalidAlignmentElem. /// InvalidAlignmentElem.
bool validAlignment(const TargetAlignElem &align) const { bool validAlignment(const LayoutAlignElem &align) const {
return &align != &InvalidAlignmentElem; 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. /// target data pass is registered.
void init(); void init();
@ -121,25 +121,26 @@ public:
/// ///
/// @note This has to exist, because this is a pass, but it should never be /// @note This has to exist, because this is a pass, but it should never be
/// used. /// used.
TargetData(); DataLayout();
/// Constructs a TargetData from a specification string. See init(). /// Constructs a DataLayout from a specification string. See init().
explicit TargetData(StringRef TargetDescription) explicit DataLayout(StringRef LayoutDescription)
: ImmutablePass(ID) { : ImmutablePass(ID) {
std::string errMsg = parseSpecifier(TargetDescription, this); std::string errMsg = parseSpecifier(LayoutDescription, this);
assert(errMsg == "" && "Invalid target data layout string."); assert(errMsg == "" && "Invalid target data layout string.");
(void)errMsg; (void)errMsg;
} }
/// Parses a target data specification string. Returns an error message /// Parses a target data specification string. Returns an error message
/// if the string is malformed, or the empty string on success. Optionally /// if the string is malformed, or the empty string on success. Optionally
/// initialises a TargetData object if passed a non-null pointer. /// initialises a DataLayout object if passed a non-null pointer.
static std::string parseSpecifier(StringRef TargetDescription, TargetData* td = 0); static std::string parseSpecifier(StringRef LayoutDescription,
DataLayout* td = 0);
/// Initialize target data from properties stored in the module. /// 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), ImmutablePass(ID),
LittleEndian(TD.isLittleEndian()), LittleEndian(TD.isLittleEndian()),
PointerMemSize(TD.PointerMemSize), PointerMemSize(TD.PointerMemSize),
@ -150,14 +151,14 @@ public:
LayoutMap(0) 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 isLittleEndian() const { return LittleEndian; }
bool isBigEndian() const { return !LittleEndian; } bool isBigEndian() const { return !LittleEndian; }
/// getStringRepresentation - Return the string representation of the /// 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. /// string constructor above.
std::string getStringRepresentation() const; std::string getStringRepresentation() const;
@ -195,13 +196,13 @@ public:
return false; return false;
} }
/// Target pointer alignment /// Layout pointer alignment
unsigned getPointerABIAlignment() const { return PointerABIAlign; } 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; } unsigned getPointerPrefAlignment() const { return PointerPrefAlign; }
/// Target pointer size /// Layout pointer size
unsigned getPointerSize() const { return PointerMemSize; } unsigned getPointerSize() const { return PointerMemSize; }
/// Target pointer size, in bits /// Layout pointer size, in bits
unsigned getPointerSizeInBits() const { return 8*PointerMemSize; } unsigned getPointerSizeInBits() const { return 8*PointerMemSize; }
/// Size examples: /// Size examples:
@ -318,7 +319,7 @@ public:
}; };
/// StructLayout - used to lazily calculate structure layout information for a /// 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 { class StructLayout {
uint64_t StructSize; uint64_t StructSize;
@ -354,8 +355,8 @@ public:
} }
private: private:
friend class TargetData; // Only TargetData can create this class friend class DataLayout; // Only DataLayout can create this class
StructLayout(StructType *ST, const TargetData &TD); StructLayout(StructType *ST, const DataLayout &TD);
}; };
} // End llvm namespace } // End llvm namespace

1
include/llvm/InitializePasses.h
View File

@ -247,6 +247,7 @@ void initializeTailCallElimPass(PassRegistry&);
void initializeTailDuplicatePassPass(PassRegistry&); void initializeTailDuplicatePassPass(PassRegistry&);
void initializeTargetPassConfigPass(PassRegistry&); void initializeTargetPassConfigPass(PassRegistry&);
void initializeTargetDataPass(PassRegistry&); void initializeTargetDataPass(PassRegistry&);
void initializeDataLayoutPass(PassRegistry&);
void initializeTargetLibraryInfoPass(PassRegistry&); void initializeTargetLibraryInfoPass(PassRegistry&);
void initializeTwoAddressInstructionPassPass(PassRegistry&); void initializeTwoAddressInstructionPassPass(PassRegistry&);
void initializeTypeBasedAliasAnalysisPass(PassRegistry&); void initializeTypeBasedAliasAnalysisPass(PassRegistry&);

96
lib/VMCore/DataLayout.cpp
View File

@ -1,4 +1,4 @@
//===-- TargetData.cpp - Data size & alignment routines --------------------==// //===-- DataLayout.cpp - Data size & alignment routines --------------------==//
// //
// The LLVM Compiler Infrastructure // 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. // information.
// //
// This structure should be created once, filled in if the defaults are not // 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/Constants.h"
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "llvm/Module.h" #include "llvm/Module.h"
@ -31,17 +31,17 @@
#include <cstdlib> #include <cstdlib>
using namespace llvm; 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... // Register the default SparcV9 implementation...
INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true) INITIALIZE_PASS(DataLayout, "datalayout", "Data Layout", false, true)
char TargetData::ID = 0; char DataLayout::ID = 0;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Support for StructLayout // 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"); assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
StructAlignment = 0; StructAlignment = 0;
StructSize = 0; StructSize = 0;
@ -54,7 +54,7 @@ StructLayout::StructLayout(StructType *ST, const TargetData &TD) {
// Add padding if necessary to align the data element properly. // Add padding if necessary to align the data element properly.
if ((StructSize & (TyAlign-1)) != 0) if ((StructSize & (TyAlign-1)) != 0)
StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign); StructSize = DataLayout::RoundUpAlignment(StructSize, TyAlign);
// Keep track of maximum alignment constraint. // Keep track of maximum alignment constraint.
StructAlignment = std::max(TyAlign, StructAlignment); 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 // 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. // and all array elements would be aligned correctly.
if ((StructSize & (StructAlignment-1)) != 0) 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 LayoutAlignElem
TargetAlignElem::get(AlignTypeEnum align_type, unsigned abi_align, LayoutAlignElem::get(AlignTypeEnum align_type, unsigned abi_align,
unsigned pref_align, uint32_t bit_width) { unsigned pref_align, uint32_t bit_width) {
assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
TargetAlignElem retval; LayoutAlignElem retval;
retval.AlignType = align_type; retval.AlignType = align_type;
retval.ABIAlign = abi_align; retval.ABIAlign = abi_align;
retval.PrefAlign = pref_align; retval.PrefAlign = pref_align;
@ -110,18 +110,18 @@ TargetAlignElem::get(AlignTypeEnum align_type, unsigned abi_align,
} }
bool bool
TargetAlignElem::operator==(const TargetAlignElem &rhs) const { LayoutAlignElem::operator==(const LayoutAlignElem &rhs) const {
return (AlignType == rhs.AlignType return (AlignType == rhs.AlignType
&& ABIAlign == rhs.ABIAlign && ABIAlign == rhs.ABIAlign
&& PrefAlign == rhs.PrefAlign && PrefAlign == rhs.PrefAlign
&& TypeBitWidth == rhs.TypeBitWidth); && TypeBitWidth == rhs.TypeBitWidth);
} }
const TargetAlignElem const LayoutAlignElem
TargetData::InvalidAlignmentElem = { (AlignTypeEnum)0xFF, 0, 0, 0 }; DataLayout::InvalidAlignmentElem = { (AlignTypeEnum)0xFF, 0, 0, 0 };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TargetData Class Implementation // DataLayout Class Implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// getInt - Get an integer ignoring errors. /// getInt - Get an integer ignoring errors.
@ -131,8 +131,8 @@ static int getInt(StringRef R) {
return Result; return Result;
} }
void TargetData::init() { void DataLayout::init() {
initializeTargetDataPass(*PassRegistry::getPassRegistry()); initializeDataLayoutPass(*PassRegistry::getPassRegistry());
LayoutMap = 0; LayoutMap = 0;
LittleEndian = false; LittleEndian = false;
@ -156,7 +156,7 @@ void TargetData::init() {
setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct 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) if (td)
td->init(); td->init();
@ -256,7 +256,7 @@ std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) {
unsigned PrefAlign = PrefAlignBits / 8; unsigned PrefAlign = PrefAlignBits / 8;
if (PrefAlign == 0) if (PrefAlign == 0)
PrefAlign = ABIAlign; PrefAlign = ABIAlign;
if (td) if (td)
td->setAlignment(AlignType, ABIAlign, PrefAlign, Size); td->setAlignment(AlignType, ABIAlign, PrefAlign, Size);
break; break;
@ -266,8 +266,8 @@ std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) {
do { do {
int Width = getInt(Specifier); int Width = getInt(Specifier);
if (Width <= 0) { if (Width <= 0) {
return std::string("invalid native integer size \'") + Specifier.str() + return std::string("invalid native integer size \'") +
"\', must be a positive integer."; Specifier.str() + "\', must be a positive integer.";
} }
if (td && Width != 0) if (td && Width != 0)
td->LegalIntWidths.push_back(Width); 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 /// @note This has to exist, because this is a pass, but it should never be
/// used. /// used.
TargetData::TargetData() : ImmutablePass(ID) { DataLayout::DataLayout() : ImmutablePass(ID) {
report_fatal_error("Bad TargetData ctor used. " report_fatal_error("Bad DataLayout ctor used. "
"Tool did not specify a TargetData to use?"); "Tool did not specify a DataLayout to use?");
} }
TargetData::TargetData(const Module *M) DataLayout::DataLayout(const Module *M)
: ImmutablePass(ID) { : ImmutablePass(ID) {
std::string errMsg = parseSpecifier(M->getDataLayout(), this); 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)errMsg;
} }
void void
TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align, DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
unsigned pref_align, uint32_t bit_width) { unsigned pref_align, uint32_t bit_width) {
assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
assert(pref_align < (1 << 16) && "Alignment doesn't fit in bitfield"); 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)); pref_align, bit_width));
} }
/// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
/// preferred if ABIInfo = false) the target wants for the specified datatype. /// preferred if ABIInfo = false) the layout wants for the specified datatype.
unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType, unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
uint32_t BitWidth, bool ABIInfo, uint32_t BitWidth, bool ABIInfo,
Type *Ty) const { Type *Ty) const {
// Check to see if we have an exact match and remember the best match we see. // Check to see if we have an exact match and remember the best match we see.
@ -412,11 +412,11 @@ public:
} // end anonymous namespace } // end anonymous namespace
TargetData::~TargetData() { DataLayout::~DataLayout() {
delete static_cast<StructLayoutMap*>(LayoutMap); delete static_cast<StructLayoutMap*>(LayoutMap);
} }
const StructLayout *TargetData::getStructLayout(StructType *Ty) const { const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
if (!LayoutMap) if (!LayoutMap)
LayoutMap = new StructLayoutMap(); LayoutMap = new StructLayoutMap();
@ -439,7 +439,7 @@ const StructLayout *TargetData::getStructLayout(StructType *Ty) const {
return L; return L;
} }
std::string TargetData::getStringRepresentation() const { std::string DataLayout::getStringRepresentation() const {
std::string Result; std::string Result;
raw_string_ostream OS(Result); raw_string_ostream OS(Result);
@ -449,7 +449,7 @@ std::string TargetData::getStringRepresentation() const {
<< "-S" << StackNaturalAlign*8; << "-S" << StackNaturalAlign*8;
for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 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 << ':' OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
<< AI.ABIAlign*8 << ':' << AI.PrefAlign*8; << 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!"); assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
switch (Ty->getTypeID()) { switch (Ty->getTypeID()) {
case Type::LabelTyID: case Type::LabelTyID:
@ -498,7 +498,7 @@ uint64_t TargetData::getTypeSizeInBits(Type *Ty) const {
case Type::VectorTyID: case Type::VectorTyID:
return cast<VectorType>(Ty)->getBitWidth(); return cast<VectorType>(Ty)->getBitWidth();
default: 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 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
== false) for the requested type \a Ty. == 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; int AlignType = -1;
assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); 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); abi_or_pref, Ty);
} }
unsigned TargetData::getABITypeAlignment(Type *Ty) const { unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
return getAlignment(Ty, true); return getAlignment(Ty, true);
} }
/// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
/// an integer type of the specified bitwidth. /// 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); 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) for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
if (Alignments[i].AlignType == STACK_ALIGN) if (Alignments[i].AlignType == STACK_ALIGN)
return Alignments[i].ABIAlign; return Alignments[i].ABIAlign;
@ -579,11 +579,11 @@ unsigned TargetData::getCallFrameTypeAlignment(Type *Ty) const {
return getABITypeAlignment(Ty); return getABITypeAlignment(Ty);
} }
unsigned TargetData::getPrefTypeAlignment(Type *Ty) const { unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
return getAlignment(Ty, false); return getAlignment(Ty, false);
} }
unsigned TargetData::getPreferredTypeAlignmentShift(Type *Ty) const { unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const {
unsigned Align = getPrefTypeAlignment(Ty); unsigned Align = getPrefTypeAlignment(Ty);
assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
return Log2_32(Align); 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 /// getIntPtrType - Return an unsigned integer type that is the same size or
/// greater to the host pointer size. /// greater to the host pointer size.
IntegerType *TargetData::getIntPtrType(LLVMContext &C) const { IntegerType *DataLayout::getIntPtrType(LLVMContext &C) const {
return IntegerType::get(C, getPointerSizeInBits()); return IntegerType::get(C, getPointerSizeInBits());
} }
uint64_t TargetData::getIndexedOffset(Type *ptrTy, uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
ArrayRef<Value *> Indices) const { ArrayRef<Value *> Indices) const {
Type *Ty = ptrTy; Type *Ty = ptrTy;
assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()"); 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 /// getPreferredAlignment - Return the preferred alignment of the specified
/// global. This includes an explicitly requested alignment (if the global /// global. This includes an explicitly requested alignment (if the global
/// has one). /// has one).
unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const { unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const {
Type *ElemType = GV->getType()->getElementType(); Type *ElemType = GV->getType()->getElementType();
unsigned Alignment = getPrefTypeAlignment(ElemType); unsigned Alignment = getPrefTypeAlignment(ElemType);
unsigned GVAlignment = GV->getAlignment(); unsigned GVAlignment = GV->getAlignment();
@ -660,6 +660,6 @@ unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
/// getPreferredAlignmentLog - Return the preferred alignment of the /// getPreferredAlignmentLog - Return the preferred alignment of the
/// specified global, returned in log form. This includes an explicitly /// specified global, returned in log form. This includes an explicitly
/// requested alignment (if the global has one). /// 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)); return Log2_32(getPreferredAlignment(GV));
} }