mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-06-24 08:24:33 +00:00
Generalize TargetData strings, to support more interesting forms of data.
Patch by Scott Michel. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@34266 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
@ -22,6 +22,8 @@
|
||||
|
||||
#include "llvm/Pass.h"
|
||||
#include "llvm/Support/DataTypes.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include <string>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -31,45 +33,96 @@ class StructType;
|
||||
class StructLayout;
|
||||
class GlobalVariable;
|
||||
|
||||
/// Enum used to categorize the alignment types stored by TargetAlignElem
|
||||
enum AlignTypeEnum {
|
||||
INTEGER_ALIGN = 'i', ///< Integer type alignment
|
||||
PACKED_ALIGN = 'v', ///< Vector type alignment
|
||||
FLOAT_ALIGN = 'f', ///< Floating point type alignment
|
||||
AGGREGATE_ALIGN = 'a' ///< Aggregate alignment
|
||||
};
|
||||
/// Target alignment element.
|
||||
///
|
||||
/// Stores the alignment data associated with a given alignment type (pointer,
|
||||
/// integer, packed/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 {
|
||||
unsigned char AlignType; //< Alignment type (AlignTypeEnum)
|
||||
unsigned char ABIAlign; //< ABI alignment for this type/bitw
|
||||
unsigned char PrefAlign; //< Pref. alignment for this type/bitw
|
||||
short TypeBitWidth; //< Type bit width
|
||||
|
||||
/// Initializer
|
||||
static TargetAlignElem get(AlignTypeEnum align_type, unsigned char abi_align,
|
||||
unsigned char pref_align, short bit_width);
|
||||
/// Less-than predicate
|
||||
bool operator<(const TargetAlignElem &rhs) const;
|
||||
/// Equality predicate
|
||||
bool operator==(const TargetAlignElem &rhs) const;
|
||||
/// output stream operator
|
||||
std::ostream &dump(std::ostream &os) const;
|
||||
};
|
||||
|
||||
//! TargetAlignElem output stream inserter
|
||||
/*!
|
||||
@sa TargetAlignElem::dump()
|
||||
*/
|
||||
std::ostream &operator<<(std::ostream &os, const TargetAlignElem &elem);
|
||||
|
||||
class TargetData : public ImmutablePass {
|
||||
bool LittleEndian; // Defaults to false
|
||||
private:
|
||||
bool LittleEndian; ///< Defaults to false
|
||||
unsigned char PointerMemSize; ///< Pointer size in bytes
|
||||
unsigned char PointerABIAlign; ///< Pointer ABI alignment
|
||||
unsigned char PointerPrefAlign; ///< Pointer preferred global alignment
|
||||
|
||||
// ABI alignments
|
||||
unsigned char BoolABIAlignment; // Defaults to 1 byte
|
||||
unsigned char ByteABIAlignment; // Defaults to 1 byte
|
||||
unsigned char ShortABIAlignment; // Defaults to 2 bytes
|
||||
unsigned char IntABIAlignment; // Defaults to 4 bytes
|
||||
unsigned char LongABIAlignment; // Defaults to 8 bytes
|
||||
unsigned char FloatABIAlignment; // Defaults to 4 bytes
|
||||
unsigned char DoubleABIAlignment; // Defaults to 8 bytes
|
||||
unsigned char PointerMemSize; // Defaults to 8 bytes
|
||||
unsigned char PointerABIAlignment; // Defaults to 8 bytes
|
||||
//! Where the primitive type alignment data is stored.
|
||||
/*!
|
||||
@sa init().
|
||||
@note Could support multiple size pointer alignments, e.g., 32-bit pointers
|
||||
vs. 64-bit pointers by extending TargetAlignment, but for now, we don't.
|
||||
*/
|
||||
SmallVector<TargetAlignElem, 16> Alignments;
|
||||
//! Alignment iterator shorthand
|
||||
typedef SmallVector<TargetAlignElem, 16>::iterator align_iterator;
|
||||
//! Constant alignment iterator shorthand
|
||||
typedef SmallVector<TargetAlignElem, 16>::const_iterator align_const_iterator;
|
||||
//! Invalid alignment.
|
||||
/*!
|
||||
This member is a signal that a requested alignment type and bit width were
|
||||
not found in the SmallVector.
|
||||
*/
|
||||
static const TargetAlignElem InvalidAlignmentElem;
|
||||
|
||||
// Preferred stack/global type alignments
|
||||
unsigned char BoolPrefAlignment; // Defaults to BoolABIAlignment
|
||||
unsigned char BytePrefAlignment; // Defaults to ByteABIAlignment
|
||||
unsigned char ShortPrefAlignment; // Defaults to ShortABIAlignment
|
||||
unsigned char IntPrefAlignment; // Defaults to IntABIAlignment
|
||||
unsigned char LongPrefAlignment; // Defaults to LongABIAlignment
|
||||
unsigned char FloatPrefAlignment; // Defaults to FloatABIAlignment
|
||||
unsigned char DoublePrefAlignment; // Defaults to DoubleABIAlignment
|
||||
unsigned char PointerPrefAlignment; // Defaults to PointerABIAlignment
|
||||
unsigned char AggMinPrefAlignment; // Defaults to 0 bytes
|
||||
//! Set/initialize target alignments
|
||||
void setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
|
||||
unsigned char pref_align, short bit_width);
|
||||
//! Get TargetAlignElem from alignment type and bit width
|
||||
const TargetAlignElem &getAlignment(AlignTypeEnum, short) const;
|
||||
//! Internal helper method that returns requested alignment for type.
|
||||
unsigned char getAlignment(const Type *Ty, bool abi_or_pref) const;
|
||||
|
||||
/// Valid alignment predicate.
|
||||
///
|
||||
/// Predicate that tests a TargetAlignElem reference returned by get() against
|
||||
/// InvalidAlignmentElem.
|
||||
inline bool validAlignment(const TargetAlignElem &align) const {
|
||||
return (&align != &InvalidAlignmentElem);
|
||||
}
|
||||
|
||||
public:
|
||||
/// Default ctor - This has to exist, because this is a pass, but it should
|
||||
/// never be used.
|
||||
/// Default ctor.
|
||||
///
|
||||
/// @note This has to exist, because this is a pass, but it should never be
|
||||
/// used.
|
||||
TargetData() {
|
||||
assert(0 && "ERROR: Bad TargetData ctor used. "
|
||||
"Tool did not specify a TargetData to use?");
|
||||
abort();
|
||||
}
|
||||
|
||||
/// Constructs a TargetData from a string of the following format:
|
||||
/// "E-p:64:64-d:64-f:32-l:64-i:32-s:16-b:8-B:8"
|
||||
/// The above string is considered the default, and any values not specified
|
||||
/// in the string will be assumed to be as above, with the caveat that unspecified
|
||||
/// values are always assumed to be smaller than the size of a pointer.
|
||||
/// Constructs a TargetData from a specification string. See init().
|
||||
TargetData(const std::string &TargetDescription) {
|
||||
init(TargetDescription);
|
||||
}
|
||||
@ -80,143 +133,36 @@ public:
|
||||
TargetData(const TargetData &TD) :
|
||||
ImmutablePass(),
|
||||
LittleEndian(TD.isLittleEndian()),
|
||||
BoolABIAlignment(TD.getBoolABIAlignment()),
|
||||
ByteABIAlignment(TD.getByteABIAlignment()),
|
||||
ShortABIAlignment(TD.getShortABIAlignment()),
|
||||
IntABIAlignment(TD.getIntABIAlignment()),
|
||||
LongABIAlignment(TD.getLongABIAlignment()),
|
||||
FloatABIAlignment(TD.getFloatABIAlignment()),
|
||||
DoubleABIAlignment(TD.getDoubleABIAlignment()),
|
||||
PointerMemSize(TD.getPointerSize()),
|
||||
PointerABIAlignment(TD.getPointerABIAlignment()),
|
||||
BoolPrefAlignment(TD.getBoolPrefAlignment()),
|
||||
BytePrefAlignment(TD.getBytePrefAlignment()),
|
||||
ShortPrefAlignment(TD.getShortPrefAlignment()),
|
||||
IntPrefAlignment(TD.getIntPrefAlignment()),
|
||||
LongPrefAlignment(TD.getLongPrefAlignment()),
|
||||
FloatPrefAlignment(TD.getFloatPrefAlignment()),
|
||||
DoublePrefAlignment(TD.getDoublePrefAlignment()),
|
||||
PointerPrefAlignment(TD.getPointerPrefAlignment()),
|
||||
AggMinPrefAlignment(TD.getAggMinPrefAlignment()) {
|
||||
}
|
||||
PointerMemSize(TD.PointerMemSize),
|
||||
PointerABIAlign(TD.PointerABIAlign),
|
||||
PointerPrefAlign(TD.PointerPrefAlign),
|
||||
Alignments(TD.Alignments)
|
||||
{ }
|
||||
|
||||
~TargetData(); // Not virtual, do not subclass this class
|
||||
|
||||
/// Parse a target data layout string and initialize TargetData members.
|
||||
///
|
||||
/// Parse a target data layout string, initializing the various TargetData
|
||||
/// members along the way. A TargetData specification string looks like
|
||||
/// "E-p:64:64-d:64-f:32-l:64-i:32-s:16-b:8-B:8" and specifies the
|
||||
/// target's endianess, the ABI alignments of various data types and
|
||||
/// the size of pointers.
|
||||
///
|
||||
/// "-" is used as a separator and ":" separates a token from its argument.
|
||||
///
|
||||
/// Alignment is indicated in bits and internally converted to the
|
||||
/// appropriate number of bytes.
|
||||
///
|
||||
/// The preferred stack/global alignment specifications (":[prefalign]") are
|
||||
/// optional and default to the ABI alignment.
|
||||
///
|
||||
/// Valid tokens:
|
||||
/// <br>
|
||||
/// <em>E</em> specifies big endian architecture (1234) [default]<br>
|
||||
/// <em>e</em> specifies little endian architecture (4321) <br>
|
||||
/// <em>p:[ptr size]:[ptr align]</em> specifies pointer size and alignment
|
||||
/// [default = 64:64] <br>
|
||||
/// <em>d:[align]:[prefalign]</em> specifies double floating
|
||||
/// point alignment [default = 64] <br>
|
||||
/// <em>f:[align]:[prefalign]</em> specifies single floating
|
||||
/// point alignment [default = 32] <br>
|
||||
/// <em>l:[align]:[prefalign]:[globalign[</em> specifies long integer
|
||||
/// alignment [default = 64] <br>
|
||||
/// <em>i:[align]:[prefalign]</em> specifies integer alignment
|
||||
/// [default = 32] <br>
|
||||
/// <em>s:[align]:[prefalign]</em> specifies short integer
|
||||
/// alignment [default = 16] <br>
|
||||
/// <em>b:[align]:[prefalign]</em> specifies byte data type
|
||||
/// alignment [default = 8] <br>
|
||||
/// <em>B:[align]:[prefalign]</em> specifies boolean data type
|
||||
/// alignment [default = 8] <br>
|
||||
/// <em>A:[prefalign]</em> specifies an aggregates' minimum alignment
|
||||
/// on the stack and when emitted as a global. The default minimum aggregate
|
||||
/// alignment defaults to 0, which causes the aggregate's "natural" internal
|
||||
/// alignment calculated by llvm to be preferred.
|
||||
///
|
||||
/// All other token types are silently ignored.
|
||||
//! Parse a target data layout string and initialize TargetData alignments.
|
||||
void init(const std::string &TargetDescription);
|
||||
|
||||
|
||||
/// Target endianness...
|
||||
bool isLittleEndian() const { return LittleEndian; }
|
||||
bool isBigEndian() const { return !LittleEndian; }
|
||||
|
||||
/// Target boolean alignment
|
||||
unsigned char getBoolABIAlignment() const { return BoolABIAlignment; }
|
||||
/// Target byte alignment
|
||||
unsigned char getByteABIAlignment() const { return ByteABIAlignment; }
|
||||
/// Target short alignment
|
||||
unsigned char getShortABIAlignment() const { return ShortABIAlignment; }
|
||||
/// Target integer alignment
|
||||
unsigned char getIntABIAlignment() const { return IntABIAlignment; }
|
||||
/// Target long alignment
|
||||
unsigned char getLongABIAlignment() const { return LongABIAlignment; }
|
||||
/// Target single precision float alignment
|
||||
unsigned char getFloatABIAlignment() const { return FloatABIAlignment; }
|
||||
/// Target double precision float alignment
|
||||
unsigned char getDoubleABIAlignment() const { return DoubleABIAlignment; }
|
||||
/// Target pointer alignment
|
||||
unsigned char getPointerABIAlignment() const { return PointerABIAlignment; }
|
||||
/// Target pointer size
|
||||
unsigned char getPointerSize() const { return PointerMemSize; }
|
||||
/// Target pointer size, in bits
|
||||
unsigned char getPointerSizeInBits() const { return 8*PointerMemSize; }
|
||||
|
||||
/// Return target's alignment for booleans on stack
|
||||
unsigned char getBoolPrefAlignment() const {
|
||||
return BoolPrefAlignment;
|
||||
}
|
||||
/// Return target's alignment for integers on stack
|
||||
unsigned char getBytePrefAlignment() const {
|
||||
return BytePrefAlignment;
|
||||
}
|
||||
/// Return target's alignment for shorts on stack
|
||||
unsigned char getShortPrefAlignment() const {
|
||||
return ShortPrefAlignment;
|
||||
}
|
||||
/// Return target's alignment for integers on stack
|
||||
unsigned char getIntPrefAlignment() const {
|
||||
return IntPrefAlignment;
|
||||
}
|
||||
/// Return target's alignment for longs on stack
|
||||
unsigned char getLongPrefAlignment() const {
|
||||
return LongPrefAlignment;
|
||||
}
|
||||
/// Return target's alignment for single precision floats on stack
|
||||
unsigned char getFloatPrefAlignment() const {
|
||||
return FloatPrefAlignment;
|
||||
}
|
||||
/// Return target's alignment for double preceision floats on stack
|
||||
unsigned char getDoublePrefAlignment() const {
|
||||
return DoublePrefAlignment;
|
||||
}
|
||||
/// Return target's alignment for stack-based pointers
|
||||
unsigned char getPointerPrefAlignment() const {
|
||||
return PointerPrefAlignment;
|
||||
}
|
||||
/// Return target's alignment for stack-based structures
|
||||
unsigned char getAggMinPrefAlignment() const {
|
||||
return AggMinPrefAlignment;
|
||||
}
|
||||
|
||||
/// getStringRepresentation - Return the string representation of the
|
||||
/// TargetData. This representation is in the same format accepted by the
|
||||
/// string constructor above.
|
||||
std::string getStringRepresentation() const;
|
||||
/// Target pointer alignment
|
||||
unsigned char getPointerABIAlignment() const { return PointerABIAlign; }
|
||||
/// Return target's alignment for stack-based pointers
|
||||
unsigned char getPointerPrefAlignment() const { return PointerPrefAlign; }
|
||||
/// Target pointer size
|
||||
unsigned char getPointerSize() const { return PointerMemSize; }
|
||||
/// Target pointer size, in bits
|
||||
unsigned char getPointerSizeInBits() const { return 8*PointerMemSize; }
|
||||
|
||||
/// getTypeSize - Return the number of bytes necessary to hold the specified
|
||||
/// type.
|
||||
///
|
||||
uint64_t getTypeSize(const Type *Ty) const;
|
||||
|
||||
/// getTypeSizeInBits - Return the number of bytes necessary to hold the
|
||||
@ -225,11 +171,11 @@ public:
|
||||
|
||||
/// getTypeAlignmentABI - Return the minimum ABI-required alignment for the
|
||||
/// specified type.
|
||||
unsigned char getTypeAlignmentABI(const Type *Ty) const;
|
||||
unsigned char getABITypeAlignment(const Type *Ty) const;
|
||||
|
||||
/// getTypeAlignmentPref - Return the preferred stack/global alignment for
|
||||
/// the specified type.
|
||||
unsigned char getTypeAlignmentPref(const Type *Ty) const;
|
||||
unsigned char getPrefTypeAlignment(const Type *Ty) const;
|
||||
|
||||
/// getPreferredTypeAlignmentShift - Return the preferred alignment for the
|
||||
/// specified type, returned as log2 of the value (a shift amount).
|
||||
|
||||
Reference in New Issue
Block a user