Structure with information about how a bitfield should be accessed. More...

#include <CGRecordLayout.h>

Collaboration diagram for clang::CodeGen::CGBitFieldInfo:

Public Member Functions
	CGBitFieldInfo ()
	CGBitFieldInfo (unsigned Offset, unsigned Size, bool IsSigned, unsigned StorageSize, unsigned StorageAlignment)
void	print (raw_ostream &OS) const
void	dump () const
Static Public Member Functions
static CGBitFieldInfo	MakeInfo (class CodeGenTypes &Types, const FieldDecl *FD, uint64_t Offset, uint64_t Size, uint64_t StorageSize, uint64_t StorageAlignment)
	Given a bit-field decl, build an appropriate helper object for accessing that field (which is expected to have the given offset and size).
Public Attributes
unsigned	Offset: 16
unsigned	Size: 15
	The total size of the bit-field, in bits.
unsigned	IsSigned: 1
	Whether the bit-field is signed.
unsigned	StorageSize
unsigned	StorageAlignment
	The alignment which should be used when accessing the bitfield.

Detailed Description

Structure with information about how a bitfield should be accessed.

Often we layout a sequence of bitfields as a contiguous sequence of bits. When the AST record layout does this, we represent it in the LLVM IR's type as either a sequence of i8 members or a byte array to reserve the number of bytes touched without forcing any particular alignment beyond the basic character alignment.

Then accessing a particular bitfield involves converting this byte array into a single integer of that size (i24 or i40 -- may not be power-of-two size), loading it, and shifting and masking to extract the particular subsequence of bits which make up that particular bitfield. This structure encodes the information used to construct the extraction code sequences. The CGRecordLayout also has a field index which encodes which byte-sequence this bitfield falls within. Let's assume the following C struct:

struct S { char a, b, c; unsigned bits : 3; unsigned more_bits : 4; unsigned still_more_bits : 7; };

This will end up as the following LLVM type. The first array is the bitfield, and the second is the padding out to a 4-byte alignmnet.

t = type { i8, i8, i8, i8, i8, [3 x i8] }

When generating code to access more_bits, we'll generate something essentially like this:

define i32 (t* base) { %0 = gep t* base, i32 0, i32 3 %2 = load i8* %1 %3 = lshr i8 %2, 3 %4 = and i8 %3, 15 %5 = zext i8 %4 to i32 ret i32 i }

Definition at line 66 of file CGRecordLayout.h.

Constructor & Destructor Documentation

clang::CodeGen::CGBitFieldInfo::CGBitFieldInfo ( ) [inline]

Definition at line 84 of file CGRecordLayout.h.

clang::CodeGen::CGBitFieldInfo::CGBitFieldInfo	(	unsigned	Offset,
		unsigned	Size,
		bool	IsSigned,
		unsigned	StorageSize,
		unsigned	StorageAlignment
	)		`[inline]`

Definition at line 87 of file CGRecordLayout.h.

Member Function Documentation

void CGBitFieldInfo::dump ( ) const

Definition at line 842 of file CGRecordLayoutBuilder.cpp.

CGBitFieldInfo CGBitFieldInfo::MakeInfo	(	class CodeGenTypes &	Types,
		const FieldDecl *	FD,
		uint64_t	Offset,
		uint64_t	Size,
		uint64_t	StorageSize,
		uint64_t	StorageAlignment
	)		`[static]`