mirror of
https://github.com/opnsense/src.git
synced 2026-02-26 03:13:02 -05:00
263 lines
9 KiB
C++
263 lines
9 KiB
C++
//===--- RecordLayout.h - Layout information for a struct/union -*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the RecordLayout interface.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_AST_LAYOUTINFO_H
|
|
#define LLVM_CLANG_AST_LAYOUTINFO_H
|
|
|
|
#include "llvm/System/DataTypes.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "clang/AST/DeclCXX.h"
|
|
|
|
namespace clang {
|
|
class ASTContext;
|
|
class FieldDecl;
|
|
class RecordDecl;
|
|
class CXXRecordDecl;
|
|
|
|
/// ASTRecordLayout -
|
|
/// This class contains layout information for one RecordDecl,
|
|
/// which is a struct/union/class. The decl represented must be a definition,
|
|
/// not a forward declaration.
|
|
/// This class is also used to contain layout information for one
|
|
/// ObjCInterfaceDecl. FIXME - Find appropriate name.
|
|
/// These objects are managed by ASTContext.
|
|
class ASTRecordLayout {
|
|
/// Size - Size of record in bits.
|
|
uint64_t Size;
|
|
|
|
/// DataSize - Size of record in bits without tail padding.
|
|
uint64_t DataSize;
|
|
|
|
/// FieldOffsets - Array of field offsets in bits.
|
|
uint64_t *FieldOffsets;
|
|
|
|
// Alignment - Alignment of record in bits.
|
|
unsigned Alignment;
|
|
|
|
// FieldCount - Number of fields.
|
|
unsigned FieldCount;
|
|
|
|
public:
|
|
/// PrimaryBaseInfo - Contains info about a primary base.
|
|
struct PrimaryBaseInfo {
|
|
PrimaryBaseInfo() {}
|
|
|
|
PrimaryBaseInfo(const CXXRecordDecl *Base, bool IsVirtual)
|
|
: Value(Base, Base && IsVirtual) {}
|
|
|
|
/// Value - Points to the primary base. The single-bit value
|
|
/// will be non-zero when the primary base is virtual.
|
|
llvm::PointerIntPair<const CXXRecordDecl *, 1, bool> Value;
|
|
|
|
/// getBase - Returns the primary base.
|
|
const CXXRecordDecl *getBase() const { return Value.getPointer(); }
|
|
|
|
/// isVirtual - Returns whether the primary base is virtual or not.
|
|
bool isVirtual() const { return Value.getInt(); }
|
|
|
|
friend bool operator==(const PrimaryBaseInfo &X, const PrimaryBaseInfo &Y) {
|
|
return X.Value == Y.Value;
|
|
}
|
|
};
|
|
|
|
/// primary_base_info_iterator - An iterator for iterating the primary base
|
|
/// class chain.
|
|
class primary_base_info_iterator {
|
|
/// Current - The current base class info.
|
|
PrimaryBaseInfo Current;
|
|
|
|
public:
|
|
primary_base_info_iterator() {}
|
|
primary_base_info_iterator(PrimaryBaseInfo Info) : Current(Info) {}
|
|
|
|
const PrimaryBaseInfo &operator*() const { return Current; }
|
|
|
|
primary_base_info_iterator& operator++() {
|
|
const CXXRecordDecl *RD = Current.getBase();
|
|
Current = RD->getASTContext().getASTRecordLayout(RD).getPrimaryBaseInfo();
|
|
return *this;
|
|
}
|
|
|
|
friend bool operator==(const primary_base_info_iterator &X,
|
|
const primary_base_info_iterator &Y) {
|
|
return X.Current == Y.Current;
|
|
}
|
|
friend bool operator!=(const primary_base_info_iterator &X,
|
|
const primary_base_info_iterator &Y) {
|
|
return !(X == Y);
|
|
}
|
|
};
|
|
|
|
private:
|
|
/// CXXRecordLayoutInfo - Contains C++ specific layout information.
|
|
struct CXXRecordLayoutInfo {
|
|
/// NonVirtualSize - The non-virtual size (in bits) of an object, which is
|
|
/// the size of the object without virtual bases.
|
|
uint64_t NonVirtualSize;
|
|
|
|
/// NonVirtualAlign - The non-virtual alignment (in bits) of an object,
|
|
/// which is the alignment of the object without virtual bases.
|
|
uint64_t NonVirtualAlign;
|
|
|
|
/// PrimaryBase - The primary base info for this record.
|
|
PrimaryBaseInfo PrimaryBase;
|
|
|
|
/// BaseOffsets - Contains a map from base classes to their offset.
|
|
/// FIXME: This should really use a SmallPtrMap, once we have one in LLVM :)
|
|
llvm::DenseMap<const CXXRecordDecl *, uint64_t> BaseOffsets;
|
|
|
|
/// VBaseOffsets - Contains a map from vbase classes to their offset.
|
|
/// FIXME: This should really use a SmallPtrMap, once we have one in LLVM :)
|
|
llvm::DenseMap<const CXXRecordDecl *, uint64_t> VBaseOffsets;
|
|
};
|
|
|
|
/// CXXInfo - If the record layout is for a C++ record, this will have
|
|
/// C++ specific information about the record.
|
|
CXXRecordLayoutInfo *CXXInfo;
|
|
|
|
friend class ASTContext;
|
|
friend class ASTRecordLayoutBuilder;
|
|
|
|
ASTRecordLayout(uint64_t size, unsigned alignment, unsigned datasize,
|
|
const uint64_t *fieldoffsets, unsigned fieldcount)
|
|
: Size(size), DataSize(datasize), FieldOffsets(0), Alignment(alignment),
|
|
FieldCount(fieldcount), CXXInfo(0) {
|
|
if (FieldCount > 0) {
|
|
FieldOffsets = new uint64_t[FieldCount];
|
|
for (unsigned i = 0; i < FieldCount; ++i)
|
|
FieldOffsets[i] = fieldoffsets[i];
|
|
}
|
|
}
|
|
|
|
// Constructor for C++ records.
|
|
ASTRecordLayout(uint64_t size, unsigned alignment, uint64_t datasize,
|
|
const uint64_t *fieldoffsets, unsigned fieldcount,
|
|
uint64_t nonvirtualsize, unsigned nonvirtualalign,
|
|
const PrimaryBaseInfo &PrimaryBase,
|
|
const std::pair<const CXXRecordDecl *, uint64_t> *bases,
|
|
unsigned numbases,
|
|
const std::pair<const CXXRecordDecl *, uint64_t> *vbases,
|
|
unsigned numvbases)
|
|
: Size(size), DataSize(datasize), FieldOffsets(0), Alignment(alignment),
|
|
FieldCount(fieldcount), CXXInfo(new CXXRecordLayoutInfo) {
|
|
if (FieldCount > 0) {
|
|
FieldOffsets = new uint64_t[FieldCount];
|
|
for (unsigned i = 0; i < FieldCount; ++i)
|
|
FieldOffsets[i] = fieldoffsets[i];
|
|
}
|
|
|
|
CXXInfo->PrimaryBase = PrimaryBase;
|
|
CXXInfo->NonVirtualSize = nonvirtualsize;
|
|
CXXInfo->NonVirtualAlign = nonvirtualalign;
|
|
for (unsigned i = 0; i != numbases; ++i)
|
|
CXXInfo->BaseOffsets[bases[i].first] = bases[i].second;
|
|
for (unsigned i = 0; i != numvbases; ++i)
|
|
CXXInfo->VBaseOffsets[vbases[i].first] = vbases[i].second;
|
|
}
|
|
|
|
~ASTRecordLayout() {
|
|
delete [] FieldOffsets;
|
|
delete CXXInfo;
|
|
}
|
|
|
|
ASTRecordLayout(const ASTRecordLayout&); // DO NOT IMPLEMENT
|
|
void operator=(const ASTRecordLayout&); // DO NOT IMPLEMENT
|
|
public:
|
|
|
|
/// getAlignment - Get the record alignment in bits.
|
|
unsigned getAlignment() const { return Alignment; }
|
|
|
|
/// getSize - Get the record size in bits.
|
|
uint64_t getSize() const { return Size; }
|
|
|
|
/// getFieldCount - Get the number of fields in the layout.
|
|
unsigned getFieldCount() const { return FieldCount; }
|
|
|
|
/// getFieldOffset - Get the offset of the given field index, in
|
|
/// bits.
|
|
uint64_t getFieldOffset(unsigned FieldNo) const {
|
|
assert (FieldNo < FieldCount && "Invalid Field No");
|
|
return FieldOffsets[FieldNo];
|
|
}
|
|
|
|
/// getDataSize() - Get the record data size, which is the record size
|
|
/// without tail padding, in bits.
|
|
uint64_t getDataSize() const {
|
|
return DataSize;
|
|
}
|
|
|
|
/// getNonVirtualSize - Get the non-virtual size (in bits) of an object,
|
|
/// which is the size of the object without virtual bases.
|
|
uint64_t getNonVirtualSize() const {
|
|
assert(CXXInfo && "Record layout does not have C++ specific info!");
|
|
|
|
return CXXInfo->NonVirtualSize;
|
|
}
|
|
|
|
/// getNonVirtualSize - Get the non-virtual alignment (in bits) of an object,
|
|
/// which is the alignment of the object without virtual bases.
|
|
unsigned getNonVirtualAlign() const {
|
|
assert(CXXInfo && "Record layout does not have C++ specific info!");
|
|
|
|
return CXXInfo->NonVirtualAlign;
|
|
}
|
|
|
|
/// getPrimaryBaseInfo - Get the primary base info.
|
|
const PrimaryBaseInfo &getPrimaryBaseInfo() const {
|
|
assert(CXXInfo && "Record layout does not have C++ specific info!");
|
|
|
|
return CXXInfo->PrimaryBase;
|
|
}
|
|
|
|
// FIXME: Migrate off of this function and use getPrimaryBaseInfo directly.
|
|
const CXXRecordDecl *getPrimaryBase() const {
|
|
return getPrimaryBaseInfo().getBase();
|
|
}
|
|
|
|
// FIXME: Migrate off of this function and use getPrimaryBaseInfo directly.
|
|
bool getPrimaryBaseWasVirtual() const {
|
|
return getPrimaryBaseInfo().isVirtual();
|
|
}
|
|
|
|
/// getBaseClassOffset - Get the offset, in bits, for the given base class.
|
|
uint64_t getBaseClassOffset(const CXXRecordDecl *Base) const {
|
|
assert(CXXInfo && "Record layout does not have C++ specific info!");
|
|
assert(CXXInfo->BaseOffsets.count(Base) && "Did not find base!");
|
|
|
|
return CXXInfo->BaseOffsets[Base];
|
|
}
|
|
|
|
/// getVBaseClassOffset - Get the offset, in bits, for the given base class.
|
|
uint64_t getVBaseClassOffset(const CXXRecordDecl *VBase) const {
|
|
assert(CXXInfo && "Record layout does not have C++ specific info!");
|
|
assert(CXXInfo->VBaseOffsets.count(VBase) && "Did not find base!");
|
|
|
|
return CXXInfo->VBaseOffsets[VBase];
|
|
}
|
|
|
|
primary_base_info_iterator primary_base_begin() const {
|
|
assert(CXXInfo && "Record layout does not have C++ specific info!");
|
|
|
|
return primary_base_info_iterator(getPrimaryBaseInfo());
|
|
}
|
|
|
|
primary_base_info_iterator primary_base_end() const {
|
|
assert(CXXInfo && "Record layout does not have C++ specific info!");
|
|
|
|
return primary_base_info_iterator();
|
|
}
|
|
};
|
|
|
|
} // end namespace clang
|
|
|
|
#endif
|