[llvm-commits] CVS: llvm/include/llvm/Target/TargetData.h
Chris Lattner
sabre at nondot.org
Tue Feb 13 21:52:56 PST 2007
Changes in directory llvm/include/llvm/Target:
TargetData.h updated: 1.53 -> 1.54
---
Log message:
Generalize TargetData strings, to support more interesting forms of data.
Patch by Scott Michel.
---
Diffs of the changes: (+99 -153)
TargetData.h | 252 +++++++++++++++++++++++------------------------------------
1 files changed, 99 insertions(+), 153 deletions(-)
Index: llvm/include/llvm/Target/TargetData.h
diff -u llvm/include/llvm/Target/TargetData.h:1.53 llvm/include/llvm/Target/TargetData.h:1.54
--- llvm/include/llvm/Target/TargetData.h:1.53 Sat Feb 10 14:37:40 2007
+++ llvm/include/llvm/Target/TargetData.h Tue Feb 13 23:52:16 2007
@@ -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 StructLayout;
class GlobalVariable;
-class TargetData : public ImmutablePass {
- bool LittleEndian; // Defaults to false
+/// 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;
+};
- // 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
-
- // 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
+//! TargetAlignElem output stream inserter
+/*!
+ @sa TargetAlignElem::dump()
+ */
+std::ostream &operator<<(std::ostream &os, const TargetAlignElem &elem);
+
+class TargetData : public ImmutablePass {
+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
+
+ //! 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;
+
+ //! 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 @@
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 @@
/// 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).
More information about the llvm-commits
mailing list