LLVM  15.0.0git
AsmPrinterDwarf.cpp
Go to the documentation of this file.
1 //===-- AsmPrinterDwarf.cpp - AsmPrinter Dwarf Support --------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Dwarf emissions parts of AsmPrinter.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/ADT/Twine.h"
16 #include "llvm/CodeGen/DIE.h"
18 #include "llvm/IR/DataLayout.h"
19 #include "llvm/MC/MCAsmInfo.h"
20 #include "llvm/MC/MCDwarf.h"
21 #include "llvm/MC/MCSection.h"
22 #include "llvm/MC/MCStreamer.h"
23 #include "llvm/MC/MCSymbol.h"
26 #include <cstdint>
27 using namespace llvm;
28 
29 #define DEBUG_TYPE "asm-printer"
30 
31 //===----------------------------------------------------------------------===//
32 // Dwarf Emission Helper Routines
33 //===----------------------------------------------------------------------===//
34 
35 /// EmitSLEB128 - emit the specified signed leb128 value.
36 void AsmPrinter::emitSLEB128(int64_t Value, const char *Desc) const {
37  if (isVerbose() && Desc)
38  OutStreamer->AddComment(Desc);
39 
40  OutStreamer->emitSLEB128IntValue(Value);
41 }
42 
43 void AsmPrinter::emitULEB128(uint64_t Value, const char *Desc,
44  unsigned PadTo) const {
45  if (isVerbose() && Desc)
46  OutStreamer->AddComment(Desc);
47 
48  OutStreamer->emitULEB128IntValue(Value, PadTo);
49 }
50 
51 /// Emit something like ".uleb128 Hi-Lo".
53  const MCSymbol *Lo) const {
54  OutStreamer->emitAbsoluteSymbolDiffAsULEB128(Hi, Lo);
55 }
56 
57 static const char *DecodeDWARFEncoding(unsigned Encoding) {
58  switch (Encoding) {
60  return "absptr";
62  return "omit";
64  return "pcrel";
66  return "uleb128";
68  return "sleb128";
70  return "udata4";
72  return "udata8";
74  return "sdata4";
76  return "sdata8";
78  return "pcrel udata4";
80  return "pcrel sdata4";
82  return "pcrel udata8";
84  return "pcrel sdata8";
86  :
87  return "indirect pcrel udata4";
89  :
90  return "indirect pcrel sdata4";
92  :
93  return "indirect pcrel udata8";
95  :
96  return "indirect pcrel sdata8";
99  return "indirect datarel sdata4";
102  return "indirect datarel sdata8";
103  }
104 
105  return "<unknown encoding>";
106 }
107 
108 /// EmitEncodingByte - Emit a .byte 42 directive that corresponds to an
109 /// encoding. If verbose assembly output is enabled, we output comments
110 /// describing the encoding. Desc is an optional string saying what the
111 /// encoding is specifying (e.g. "LSDA").
112 void AsmPrinter::emitEncodingByte(unsigned Val, const char *Desc) const {
113  if (isVerbose()) {
114  if (Desc)
115  OutStreamer->AddComment(Twine(Desc) + " Encoding = " +
116  Twine(DecodeDWARFEncoding(Val)));
117  else
118  OutStreamer->AddComment(Twine("Encoding = ") + DecodeDWARFEncoding(Val));
119  }
120 
121  OutStreamer->emitIntValue(Val, 1);
122 }
123 
124 /// GetSizeOfEncodedValue - Return the size of the encoding in bytes.
125 unsigned AsmPrinter::GetSizeOfEncodedValue(unsigned Encoding) const {
126  if (Encoding == dwarf::DW_EH_PE_omit)
127  return 0;
128 
129  switch (Encoding & 0x07) {
130  default:
131  llvm_unreachable("Invalid encoded value.");
133  return MF->getDataLayout().getPointerSize();
135  return 2;
137  return 4;
139  return 8;
140  }
141 }
142 
143 void AsmPrinter::emitTTypeReference(const GlobalValue *GV, unsigned Encoding) {
144  if (GV) {
146 
147  const MCExpr *Exp =
148  TLOF.getTTypeGlobalReference(GV, Encoding, TM, MMI, *OutStreamer);
149  OutStreamer->emitValue(Exp, GetSizeOfEncodedValue(Encoding));
150  } else
151  OutStreamer->emitIntValue(0, GetSizeOfEncodedValue(Encoding));
152 }
153 
155  bool ForceOffset) const {
156  if (!ForceOffset) {
157  // On COFF targets, we have to emit the special .secrel32 directive.
159  assert(!isDwarf64() &&
160  "emitting DWARF64 is not implemented for COFF targets");
161  OutStreamer->emitCOFFSecRel32(Label, /*Offset=*/0);
162  return;
163  }
164 
165  // If the format uses relocations with dwarf, refer to the symbol directly.
167  OutStreamer->emitSymbolValue(Label, getDwarfOffsetByteSize());
168  return;
169  }
170  }
171 
172  // Otherwise, emit it as a label difference from the start of the section.
173  emitLabelDifference(Label, Label->getSection().getBeginSymbol(),
175 }
176 
179  assert(S.Symbol && "No symbol available");
180  emitDwarfSymbolReference(S.Symbol);
181  return;
182  }
183 
184  // Just emit the offset directly; no need for symbol math.
185  OutStreamer->emitIntValue(S.Offset, getDwarfOffsetByteSize());
186 }
187 
188 void AsmPrinter::emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const {
190 }
191 
193  assert(isDwarf64() || Value <= UINT32_MAX);
194  OutStreamer->emitIntValue(Value, getDwarfOffsetByteSize());
195 }
196 
198  const Twine &Comment) const {
199  OutStreamer->emitDwarfUnitLength(Length, Comment);
200 }
201 
203  const Twine &Comment) const {
204  return OutStreamer->emitDwarfUnitLength(Prefix, Comment);
205 }
206 
208  unsigned Encoding) const {
209  // The least significant 3 bits specify the width of the encoding
210  if ((Encoding & 0x7) == dwarf::DW_EH_PE_uleb128)
212  else
213  emitLabelDifference(Hi, Lo, GetSizeOfEncodedValue(Encoding));
214 }
215 
216 void AsmPrinter::emitCallSiteValue(uint64_t Value, unsigned Encoding) const {
217  // The least significant 3 bits specify the width of the encoding
218  if ((Encoding & 0x7) == dwarf::DW_EH_PE_uleb128)
220  else
221  OutStreamer->emitIntValue(Value, GetSizeOfEncodedValue(Encoding));
222 }
223 
224 //===----------------------------------------------------------------------===//
225 // Dwarf Lowering Routines
226 //===----------------------------------------------------------------------===//
227 
229  switch (Inst.getOperation()) {
230  default:
231  llvm_unreachable("Unexpected instruction");
233  OutStreamer->emitCFIDefCfaOffset(Inst.getOffset());
234  break;
236  OutStreamer->emitCFIAdjustCfaOffset(Inst.getOffset());
237  break;
239  OutStreamer->emitCFIDefCfa(Inst.getRegister(), Inst.getOffset());
240  break;
242  OutStreamer->emitCFIDefCfaRegister(Inst.getRegister());
243  break;
245  OutStreamer->emitCFILLVMDefAspaceCfa(Inst.getRegister(), Inst.getOffset(),
246  Inst.getAddressSpace());
247  break;
249  OutStreamer->emitCFIOffset(Inst.getRegister(), Inst.getOffset());
250  break;
252  OutStreamer->emitCFIRegister(Inst.getRegister(), Inst.getRegister2());
253  break;
255  OutStreamer->emitCFIWindowSave();
256  break;
258  OutStreamer->emitCFINegateRAState();
259  break;
261  OutStreamer->emitCFISameValue(Inst.getRegister());
262  break;
264  OutStreamer->emitCFIGnuArgsSize(Inst.getOffset());
265  break;
267  OutStreamer->AddComment(Inst.getComment());
268  OutStreamer->emitCFIEscape(Inst.getValues());
269  break;
271  OutStreamer->emitCFIRestore(Inst.getRegister());
272  break;
274  OutStreamer->emitCFIUndefined(Inst.getRegister());
275  break;
277  OutStreamer->emitCFIRememberState();
278  break;
280  OutStreamer->emitCFIRestoreState();
281  break;
282  }
283 }
284 
285 void AsmPrinter::emitDwarfDIE(const DIE &Die) const {
286  // Emit the code (index) for the abbreviation.
287  if (isVerbose())
288  OutStreamer->AddComment("Abbrev [" + Twine(Die.getAbbrevNumber()) + "] 0x" +
289  Twine::utohexstr(Die.getOffset()) + ":0x" +
290  Twine::utohexstr(Die.getSize()) + " " +
291  dwarf::TagString(Die.getTag()));
293 
294  // Emit the DIE attribute values.
295  for (const auto &V : Die.values()) {
296  dwarf::Attribute Attr = V.getAttribute();
297  assert(V.getForm() && "Too many attributes for DIE (check abbreviation)");
298 
299  if (isVerbose()) {
300  OutStreamer->AddComment(dwarf::AttributeString(Attr));
301  if (Attr == dwarf::DW_AT_accessibility)
302  OutStreamer->AddComment(
303  dwarf::AccessibilityString(V.getDIEInteger().getValue()));
304  }
305 
306  // Emit an attribute using the defined form.
307  V.emitValue(this);
308  }
309 
310  // Emit the DIE children if any.
311  if (Die.hasChildren()) {
312  for (auto &Child : Die.children())
313  emitDwarfDIE(Child);
314 
315  OutStreamer->AddComment("End Of Children Mark");
316  emitInt8(0);
317  }
318 }
319 
320 void AsmPrinter::emitDwarfAbbrev(const DIEAbbrev &Abbrev) const {
321  // Emit the abbreviations code (base 1 index.)
322  emitULEB128(Abbrev.getNumber(), "Abbreviation Code");
323 
324  // Emit the abbreviations data.
325  Abbrev.Emit(this);
326 }
llvm::MCCFIInstruction::OpWindowSave
@ OpWindowSave
Definition: MCDwarf.h:489
AsmPrinter.h
llvm::AsmPrinter::emitLabelDifference
void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) const
Emit something like ".long Hi-Lo" where the size in bytes of the directive is specified by Size and H...
Definition: AsmPrinter.cpp:2617
llvm::AsmPrinter::emitLabelDifferenceAsULEB128
void emitLabelDifferenceAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) const
Emit something like ".uleb128 Hi-Lo".
Definition: AsmPrinterDwarf.cpp:52
MCDwarf.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
llvm::dwarf::DW_EH_PE_sdata4
@ DW_EH_PE_sdata4
Definition: Dwarf.h:445
llvm::MCCFIInstruction::OpDefCfaRegister
@ OpDefCfaRegister
Definition: MCDwarf.h:480
llvm::MCCFIInstruction::getComment
StringRef getComment() const
Definition: MCDwarf.h:670
llvm::AsmPrinter::emitULEB128
void emitULEB128(uint64_t Value, const char *Desc=nullptr, unsigned PadTo=0) const
Emit the specified unsigned leb128 value.
Definition: AsmPrinterDwarf.cpp:43
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:160
llvm::MCCFIInstruction::OpOffset
@ OpOffset
Definition: MCDwarf.h:478
llvm::AsmPrinter::MAI
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:87
ErrorHandling.h
llvm::AsmPrinter::emitSLEB128
void emitSLEB128(int64_t Value, const char *Desc=nullptr) const
Emit the specified signed leb128 value.
Definition: AsmPrinterDwarf.cpp:36
llvm::dwarf::DW_EH_PE_sdata8
@ DW_EH_PE_sdata8
Definition: Dwarf.h:446
llvm::AsmPrinter::getDwarfOffsetByteSize
unsigned int getDwarfOffsetByteSize() const
Returns 4 for DWARF32 and 8 for DWARF64.
Definition: AsmPrinter.cpp:3818
llvm::AsmPrinter::emitDwarfOffset
void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const
Emit something like ".long Label + Offset" or ".quad Label + Offset" depending on the DWARF format.
Definition: AsmPrinterDwarf.cpp:188
llvm::DIE
A structured debug information entry.
Definition: DIE.h:739
llvm::DIE::getTag
dwarf::Tag getTag() const
Definition: DIE.h:775
llvm::AsmPrinter::emitCallSiteOffset
void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Encoding) const
Emit reference to a call site with a specified encoding.
Definition: AsmPrinterDwarf.cpp:207
llvm::dwarf::Attribute
Attribute
Attributes.
Definition: Dwarf.h:125
llvm::dwarf::AccessibilityString
StringRef AccessibilityString(unsigned Access)
Definition: Dwarf.cpp:270
llvm::DIEValueList::values
value_range values()
Definition: DIE.h:727
llvm::TargetLoweringObjectFile
Definition: TargetLoweringObjectFile.h:45
llvm::MCCFIInstruction::OpDefCfa
@ OpDefCfa
Definition: MCDwarf.h:482
llvm::DIEAbbrev
Dwarf abbreviation, describes the organization of a debug information object.
Definition: DIE.h:79
llvm::MCCFIInstruction::OpUndefined
@ OpUndefined
Definition: MCDwarf.h:487
llvm::AsmPrinter::emitDwarfAbbrev
void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const
Definition: AsmPrinterDwarf.cpp:320
llvm::dwarf::DW_EH_PE_indirect
@ DW_EH_PE_indirect
Definition: Dwarf.h:453
llvm::dwarf::DW_EH_PE_udata2
@ DW_EH_PE_udata2
Definition: Dwarf.h:440
llvm::AsmPrinter::OutStreamer
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:96
Twine.h
llvm::DIEAbbrev::Emit
void Emit(const AsmPrinter *AP) const
Print the abbreviation using the specified asm printer.
Definition: DIE.cpp:62
MCSymbol.h
llvm::MCCFIInstruction::getOffset
int getOffset() const
Definition: MCDwarf.h:657
llvm::MCAsmInfo::needsDwarfSectionOffsetDirective
bool needsDwarfSectionOffsetDirective() const
Definition: MCAsmInfo.h:623
llvm::MCCFIInstruction::getOperation
OpType getOperation() const
Definition: MCDwarf.h:635
llvm::AsmPrinter::emitDwarfSymbolReference
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
Definition: AsmPrinterDwarf.cpp:154
llvm::AsmPrinter::emitInt8
void emitInt8(int Value) const
Emit a byte directive and value.
Definition: AsmPrinter.cpp:2601
llvm::MCCFIInstruction::getRegister
unsigned getRegister() const
Definition: MCDwarf.h:638
llvm::DIE::getSize
unsigned getSize() const
Definition: DIE.h:782
llvm::MCCFIInstruction
Definition: MCDwarf.h:472
DIE.h
llvm::dwarf::DW_EH_PE_udata4
@ DW_EH_PE_udata4
Definition: Dwarf.h:441
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::Twine::utohexstr
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:408
llvm::DwarfStringPoolEntry
Data for a string pool entry.
Definition: DwarfStringPoolEntry.h:20
llvm::dwarf::DW_EH_PE_udata8
@ DW_EH_PE_udata8
Definition: Dwarf.h:442
llvm::MCCFIInstruction::OpDefCfaOffset
@ OpDefCfaOffset
Definition: MCDwarf.h:481
llvm::MCCFIInstruction::OpRestore
@ OpRestore
Definition: MCDwarf.h:486
llvm::AsmPrinter::emitLabelPlusOffset
void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, unsigned Size, bool IsSectionRelative=false) const
Emit something like ".long Label+Offset" where the size in bytes of the directive is specified by Siz...
Definition: AsmPrinter.cpp:2625
uint64_t
llvm::dwarf::DW_EH_PE_pcrel
@ DW_EH_PE_pcrel
Definition: Dwarf.h:448
llvm::AsmPrinter::GetSizeOfEncodedValue
unsigned GetSizeOfEncodedValue(unsigned Encoding) const
Return the size of the encoding in bytes.
Definition: AsmPrinterDwarf.cpp:125
llvm::MCCFIInstruction::OpSameValue
@ OpSameValue
Definition: MCDwarf.h:475
llvm::MCCFIInstruction::getRegister2
unsigned getRegister2() const
Definition: MCDwarf.h:647
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::AsmPrinter::emitDwarfUnitLength
void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const
Emit a unit length field.
Definition: AsmPrinterDwarf.cpp:197
llvm::AsmPrinter::MF
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:99
llvm::MCCFIInstruction::OpAdjustCfaOffset
@ OpAdjustCfaOffset
Definition: MCDwarf.h:484
llvm::AsmPrinter::emitDwarfLengthOrOffset
void emitDwarfLengthOrOffset(uint64_t Value) const
Emit 32- or 64-bit value depending on the DWARF format.
Definition: AsmPrinterDwarf.cpp:192
MCSection.h
llvm::AsmPrinter::emitCFIInstruction
void emitCFIInstruction(const MachineInstr &MI)
Definition: AsmPrinter.cpp:1250
llvm::MCCFIInstruction::OpEscape
@ OpEscape
Definition: MCDwarf.h:485
llvm::dwarf::DW_EH_PE_datarel
@ DW_EH_PE_datarel
Definition: Dwarf.h:450
llvm::dwarf::DW_EH_PE_uleb128
@ DW_EH_PE_uleb128
Definition: Dwarf.h:439
llvm::MCCFIInstruction::getAddressSpace
unsigned getAddressSpace() const
Definition: MCDwarf.h:652
llvm::MCCFIInstruction::OpRememberState
@ OpRememberState
Definition: MCDwarf.h:476
MCAsmInfo.h
DataLayout.h
Dwarf.h
llvm::MCCFIInstruction::getValues
StringRef getValues() const
Definition: MCDwarf.h:665
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
TargetLoweringObjectFile.h
llvm::DIE::children
child_range children()
Definition: DIE.h:795
llvm::MCCFIInstruction::OpLLVMDefAspaceCfa
@ OpLLVMDefAspaceCfa
Definition: MCDwarf.h:479
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MCAsmInfo::doesDwarfUseRelocationsAcrossSections
bool doesDwarfUseRelocationsAcrossSections() const
Definition: MCAsmInfo.h:799
DecodeDWARFEncoding
static const char * DecodeDWARFEncoding(unsigned Encoding)
Definition: AsmPrinterDwarf.cpp:57
llvm::AsmPrinter::MMI
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:102
llvm::dwarf::DW_EH_PE_sleb128
@ DW_EH_PE_sleb128
Definition: Dwarf.h:443
llvm::dwarf::DW_EH_PE_absptr
@ DW_EH_PE_absptr
Definition: Dwarf.h:437
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::AsmPrinter::isDwarf64
bool isDwarf64() const
Definition: AsmPrinter.cpp:3814
llvm::MCCFIInstruction::OpGnuArgsSize
@ OpGnuArgsSize
Definition: MCDwarf.h:491
llvm::MCCFIInstruction::OpRegister
@ OpRegister
Definition: MCDwarf.h:488
llvm::DIE::getAbbrevNumber
unsigned getAbbrevNumber() const
Definition: DIE.h:774
llvm::AsmPrinter::emitTTypeReference
virtual void emitTTypeReference(const GlobalValue *GV, unsigned Encoding)
Emit reference to a ttype global with a specified encoding.
Definition: AsmPrinterDwarf.cpp:143
llvm::AsmPrinter::TM
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:84
llvm::AsmPrinter::getObjFileLowering
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:382
MCStreamer.h
llvm::dwarf::DW_EH_PE_omit
@ DW_EH_PE_omit
Definition: Dwarf.h:438
llvm::DIE::hasChildren
bool hasChildren() const
Definition: DIE.h:787
llvm::MachineFunction::getDataLayout
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
Definition: MachineFunction.cpp:285
llvm::AsmPrinter::emitDwarfStringOffset
void emitDwarfStringOffset(DwarfStringPoolEntry S) const
Emit the 4- or 8-byte offset of a string from the start of its section.
Definition: AsmPrinterDwarf.cpp:177
llvm::AsmPrinter::emitDwarfDIE
void emitDwarfDIE(const DIE &Die) const
Recursively emit Dwarf DIE tree.
Definition: AsmPrinterDwarf.cpp:285
llvm::AsmPrinter::emitCallSiteValue
void emitCallSiteValue(uint64_t Value, unsigned Encoding) const
Emit an integer value corresponding to the call site encoding.
Definition: AsmPrinterDwarf.cpp:216
llvm::DIEAbbrev::getNumber
unsigned getNumber() const
Definition: DIE.h:101
llvm::dwarf::TagString
StringRef TagString(unsigned Tag)
Definition: Dwarf.cpp:21
llvm::AsmPrinter::isVerbose
bool isVerbose() const
Return true if assembly output should contain comments.
Definition: AsmPrinter.h:254
llvm::DIE::getOffset
unsigned getOffset() const
Get the compile/type unit relative offset of this DIE.
Definition: DIE.h:777
llvm::MCCFIInstruction::OpNegateRAState
@ OpNegateRAState
Definition: MCDwarf.h:490
MachineFunction.h
llvm::AsmPrinter::emitEncodingByte
void emitEncodingByte(unsigned Val, const char *Desc=nullptr) const
Emit a .byte 42 directive that corresponds to an encoding.
Definition: AsmPrinterDwarf.cpp:112
llvm::TargetLoweringObjectFile::getTTypeGlobalReference
virtual const MCExpr * getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, MachineModuleInfo *MMI, MCStreamer &Streamer) const
Return an MCExpr to use for a reference to the specified global variable from exception handling info...
Definition: TargetLoweringObjectFile.cpp:396
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
llvm::MCCFIInstruction::OpRestoreState
@ OpRestoreState
Definition: MCDwarf.h:477
llvm::dwarf::AttributeString
StringRef AttributeString(unsigned Attribute)
Definition: Dwarf.cpp:72
llvm::DataLayout::getPointerSize
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size in bytes, rounded up to a whole number of bytes.
Definition: DataLayout.cpp:708