mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-23 01:30:19 +00:00
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
This commit is contained in:
Micah Villmow
parent
ea2c50c041
commit
99b11484d9
@ -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<typename T>
|
||||
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<TargetAlignElem, 16> Alignments;
|
||||
SmallVector<LayoutAlignElem, 16> 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
|
||||
|
||||
@ -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&);
|
||||
|
||||
@ -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 <cstdlib>
|
||||
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<StructLayoutMap*>(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<VectorType>(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<Value *> 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));
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user