2013-12-03 03:33:10 +08:00
|
|
|
//===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
|
2011-04-13 07:21:44 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2012-08-14 13:13:29 +08:00
|
|
|
// This file contains support for constructing a dwarf compile unit.
|
2011-04-13 07:21:44 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2013-12-03 03:33:15 +08:00
|
|
|
#include "DwarfUnit.h"
|
2016-08-25 08:45:04 +08:00
|
|
|
#include "AddressPool.h"
|
2014-10-04 23:49:50 +08:00
|
|
|
#include "DwarfCompileUnit.h"
|
2011-04-13 07:21:44 +08:00
|
|
|
#include "DwarfDebug.h"
|
2015-01-13 06:19:26 +08:00
|
|
|
#include "DwarfExpression.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/APFloat.h"
|
2016-08-25 08:45:04 +08:00
|
|
|
#include "llvm/ADT/APInt.h"
|
|
|
|
#include "llvm/ADT/iterator_range.h"
|
|
|
|
#include "llvm/ADT/None.h"
|
2015-03-03 06:02:36 +08:00
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
2016-08-25 08:45:04 +08:00
|
|
|
#include "llvm/CodeGen/MachineOperand.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DataLayout.h"
|
2016-08-25 08:45:04 +08:00
|
|
|
#include "llvm/IR/GlobalValue.h"
|
|
|
|
#include "llvm/IR/Metadata.h"
|
|
|
|
#include "llvm/MC/MachineLocation.h"
|
2017-04-18 01:41:25 +08:00
|
|
|
#include "llvm/MC/MCAsmInfo.h"
|
2016-08-25 08:45:04 +08:00
|
|
|
#include "llvm/MC/MCDwarf.h"
|
2013-10-31 04:42:41 +08:00
|
|
|
#include "llvm/MC/MCSection.h"
|
|
|
|
#include "llvm/MC/MCStreamer.h"
|
2016-08-25 08:45:04 +08:00
|
|
|
#include "llvm/Support/Casting.h"
|
2014-01-07 19:48:04 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2013-06-29 04:05:11 +08:00
|
|
|
#include "llvm/Target/TargetLoweringObjectFile.h"
|
2011-04-13 07:21:44 +08:00
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
2014-08-05 05:25:23 +08:00
|
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
2016-08-25 08:45:04 +08:00
|
|
|
#include <cassert>
|
|
|
|
#include <cstdint>
|
|
|
|
#include <string>
|
|
|
|
#include <utility>
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 10:02:50 +08:00
|
|
|
#define DEBUG_TYPE "dwarfdebug"
|
|
|
|
|
2013-12-10 07:57:44 +08:00
|
|
|
static cl::opt<bool>
|
|
|
|
GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
|
|
|
|
cl::desc("Generate DWARF4 type units."),
|
|
|
|
cl::init(false));
|
2013-11-20 07:08:21 +08:00
|
|
|
|
2015-03-03 06:02:36 +08:00
|
|
|
DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
|
|
|
|
DIELoc &DIE)
|
2016-11-24 07:30:37 +08:00
|
|
|
: DwarfExpression(AP.getDwarfVersion()), AP(AP), DU(DU),
|
2016-05-21 03:35:17 +08:00
|
|
|
DIE(DIE) {}
|
2015-03-03 06:02:33 +08:00
|
|
|
|
2017-03-17 01:42:45 +08:00
|
|
|
void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
|
2015-01-13 06:19:26 +08:00
|
|
|
DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
|
|
|
|
}
|
2016-08-25 08:45:04 +08:00
|
|
|
|
2017-03-17 01:42:45 +08:00
|
|
|
void DIEDwarfExpression::emitSigned(int64_t Value) {
|
2015-01-13 06:19:26 +08:00
|
|
|
DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
|
|
|
|
}
|
2016-08-25 08:45:04 +08:00
|
|
|
|
2017-03-17 01:42:45 +08:00
|
|
|
void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
|
2015-01-13 06:19:26 +08:00
|
|
|
DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
|
|
|
|
}
|
2016-08-25 08:45:04 +08:00
|
|
|
|
2016-05-21 03:35:17 +08:00
|
|
|
bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
|
|
|
|
unsigned MachineReg) {
|
2015-03-03 06:02:33 +08:00
|
|
|
return MachineReg == TRI.getFrameRegister(*AP.MF);
|
2015-01-13 06:19:26 +08:00
|
|
|
}
|
|
|
|
|
2016-02-12 03:57:46 +08:00
|
|
|
DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
|
|
|
|
AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
|
2017-04-18 01:41:25 +08:00
|
|
|
: DIEUnit(A->getDwarfVersion(), A->MAI->getCodePointerSize(), UnitTag),
|
|
|
|
CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
|
2013-12-03 03:33:10 +08:00
|
|
|
}
|
|
|
|
|
2016-02-12 03:57:46 +08:00
|
|
|
DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
|
2014-04-29 05:04:29 +08:00
|
|
|
DwarfDebug *DW, DwarfFile *DWU,
|
2014-03-18 10:13:23 +08:00
|
|
|
MCDwarfDwoLineTable *SplitLineTable)
|
2016-02-12 03:57:46 +08:00
|
|
|
: DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
|
|
|
|
SplitLineTable(SplitLineTable) {
|
2014-03-18 09:17:26 +08:00
|
|
|
if (SplitLineTable)
|
2016-12-02 02:56:29 +08:00
|
|
|
addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
|
2014-03-18 09:17:26 +08:00
|
|
|
}
|
2013-11-20 07:08:21 +08:00
|
|
|
|
2013-12-10 07:32:48 +08:00
|
|
|
DwarfUnit::~DwarfUnit() {
|
2011-04-13 07:21:44 +08:00
|
|
|
for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
|
|
|
|
DIEBlocks[j]->~DIEBlock();
|
2014-02-16 16:46:55 +08:00
|
|
|
for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
|
|
|
|
DIELocs[j]->~DIELoc();
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2013-12-10 07:32:48 +08:00
|
|
|
int64_t DwarfUnit::getDefaultLowerBound() const {
|
2013-11-16 07:50:53 +08:00
|
|
|
switch (getLanguage()) {
|
2012-12-06 15:38:10 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
|
2017-03-02 02:32:37 +08:00
|
|
|
// The languages below have valid values in all DWARF versions.
|
2012-12-06 15:38:10 +08:00
|
|
|
case dwarf::DW_LANG_C:
|
2017-03-02 03:01:47 +08:00
|
|
|
case dwarf::DW_LANG_C89:
|
2012-12-06 15:38:10 +08:00
|
|
|
case dwarf::DW_LANG_C_plus_plus:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case dwarf::DW_LANG_Fortran77:
|
|
|
|
case dwarf::DW_LANG_Fortran90:
|
|
|
|
return 1;
|
|
|
|
|
2017-03-02 02:32:37 +08:00
|
|
|
// The languages below have valid values only if the DWARF version >= 3.
|
|
|
|
case dwarf::DW_LANG_C99:
|
|
|
|
case dwarf::DW_LANG_ObjC:
|
|
|
|
case dwarf::DW_LANG_ObjC_plus_plus:
|
|
|
|
if (DD->getDwarfVersion() >= 3)
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case dwarf::DW_LANG_Fortran95:
|
|
|
|
if (DD->getDwarfVersion() >= 3)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Starting with DWARF v4, all defined languages have valid values.
|
2017-03-02 03:01:47 +08:00
|
|
|
case dwarf::DW_LANG_D:
|
2012-12-06 15:38:10 +08:00
|
|
|
case dwarf::DW_LANG_Java:
|
|
|
|
case dwarf::DW_LANG_Python:
|
|
|
|
case dwarf::DW_LANG_UPC:
|
2017-03-02 02:32:37 +08:00
|
|
|
if (DD->getDwarfVersion() >= 4)
|
2012-12-06 15:38:10 +08:00
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case dwarf::DW_LANG_Ada83:
|
|
|
|
case dwarf::DW_LANG_Ada95:
|
|
|
|
case dwarf::DW_LANG_Cobol74:
|
|
|
|
case dwarf::DW_LANG_Cobol85:
|
|
|
|
case dwarf::DW_LANG_Modula2:
|
|
|
|
case dwarf::DW_LANG_Pascal83:
|
|
|
|
case dwarf::DW_LANG_PLI:
|
2017-03-02 02:32:37 +08:00
|
|
|
if (DD->getDwarfVersion() >= 4)
|
2012-12-06 15:38:10 +08:00
|
|
|
return 1;
|
|
|
|
break;
|
2015-02-07 14:35:30 +08:00
|
|
|
|
2017-03-02 02:32:37 +08:00
|
|
|
// The languages below are new in DWARF v5.
|
2017-03-02 03:01:47 +08:00
|
|
|
case dwarf::DW_LANG_BLISS:
|
|
|
|
case dwarf::DW_LANG_C11:
|
2015-02-07 14:35:30 +08:00
|
|
|
case dwarf::DW_LANG_C_plus_plus_03:
|
|
|
|
case dwarf::DW_LANG_C_plus_plus_11:
|
2017-03-02 03:01:47 +08:00
|
|
|
case dwarf::DW_LANG_C_plus_plus_14:
|
|
|
|
case dwarf::DW_LANG_Dylan:
|
|
|
|
case dwarf::DW_LANG_Go:
|
|
|
|
case dwarf::DW_LANG_Haskell:
|
2015-02-07 14:35:30 +08:00
|
|
|
case dwarf::DW_LANG_OCaml:
|
2017-03-02 03:01:47 +08:00
|
|
|
case dwarf::DW_LANG_OpenCL:
|
|
|
|
case dwarf::DW_LANG_RenderScript:
|
2015-02-07 14:35:30 +08:00
|
|
|
case dwarf::DW_LANG_Rust:
|
|
|
|
case dwarf::DW_LANG_Swift:
|
2017-03-02 02:32:37 +08:00
|
|
|
if (DD->getDwarfVersion() >= 5)
|
2015-02-07 14:35:30 +08:00
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case dwarf::DW_LANG_Fortran03:
|
|
|
|
case dwarf::DW_LANG_Fortran08:
|
2017-03-02 03:01:47 +08:00
|
|
|
case dwarf::DW_LANG_Julia:
|
|
|
|
case dwarf::DW_LANG_Modula3:
|
2017-03-02 02:32:37 +08:00
|
|
|
if (DD->getDwarfVersion() >= 5)
|
2015-02-07 14:35:30 +08:00
|
|
|
return 1;
|
|
|
|
break;
|
2012-12-06 15:38:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-11-01 01:54:35 +08:00
|
|
|
/// Check whether the DIE for this MDNode can be shared across CUs.
|
2015-04-30 00:38:44 +08:00
|
|
|
static bool isShareableAcrossCUs(const DINode *D) {
|
2013-11-21 02:40:16 +08:00
|
|
|
// When the MDNode can be part of the type system, the DIE can be shared
|
|
|
|
// across CUs.
|
|
|
|
// Combining type units and cross-CU DIE sharing is lower value (since
|
|
|
|
// cross-CU DIE sharing is used in LTO and removes type redundancy at that
|
|
|
|
// level already) but may be implementable for some value in projects
|
|
|
|
// building multiple independent libraries with LTO and then linking those
|
|
|
|
// together.
|
2015-04-30 00:38:44 +08:00
|
|
|
return (isa<DIType>(D) ||
|
|
|
|
(isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
|
2013-12-10 07:57:44 +08:00
|
|
|
!GenerateDwarfTypeUnits;
|
2013-11-01 01:54:35 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
DIE *DwarfUnit::getDIE(const DINode *D) const {
|
2013-11-16 07:09:13 +08:00
|
|
|
if (isShareableAcrossCUs(D))
|
2014-11-05 06:12:18 +08:00
|
|
|
return DU->getDIE(D);
|
2013-11-16 07:09:13 +08:00
|
|
|
return MDNodeToDieMap.lookup(D);
|
2013-11-01 01:54:35 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
|
2013-11-16 07:09:13 +08:00
|
|
|
if (isShareableAcrossCUs(Desc)) {
|
2014-11-05 06:12:18 +08:00
|
|
|
DU->insertDIE(Desc, D);
|
2013-11-01 01:54:35 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-11-16 07:09:13 +08:00
|
|
|
MDNodeToDieMap.insert(std::make_pair(Desc, D));
|
2013-11-01 01:54:35 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
|
2013-09-04 12:39:38 +08:00
|
|
|
if (DD->getDwarfVersion() >= 4)
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
|
|
|
|
DIEInteger(1));
|
2012-08-24 09:14:27 +08:00
|
|
|
else
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
|
|
|
|
DIEInteger(1));
|
2012-08-24 09:14:27 +08:00
|
|
|
}
|
|
|
|
|
2015-08-03 04:44:46 +08:00
|
|
|
void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
|
2013-12-10 07:32:48 +08:00
|
|
|
Optional<dwarf::Form> Form, uint64_t Integer) {
|
2013-10-19 09:04:47 +08:00
|
|
|
if (!Form)
|
|
|
|
Form = DIEInteger::BestForm(false, Integer);
|
2017-01-11 05:18:26 +08:00
|
|
|
assert(Form != dwarf::DW_FORM_implicit_const &&
|
|
|
|
"DW_FORM_implicit_const is used only for signed integers");
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
|
2013-10-22 01:28:37 +08:00
|
|
|
}
|
|
|
|
|
2015-08-03 04:44:46 +08:00
|
|
|
void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
|
|
|
|
uint64_t Integer) {
|
2013-10-22 01:28:37 +08:00
|
|
|
addUInt(Block, (dwarf::Attribute)0, Form, Integer);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-08-03 04:44:46 +08:00
|
|
|
void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
|
2013-12-10 07:32:48 +08:00
|
|
|
Optional<dwarf::Form> Form, int64_t Integer) {
|
2013-10-19 09:04:47 +08:00
|
|
|
if (!Form)
|
|
|
|
Form = DIEInteger::BestForm(true, Integer);
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
|
2013-10-22 01:28:37 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
|
2013-12-10 07:32:48 +08:00
|
|
|
int64_t Integer) {
|
2013-10-22 01:28:37 +08:00
|
|
|
addSInt(Die, (dwarf::Attribute)0, Form, Integer);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
|
2013-12-10 07:32:48 +08:00
|
|
|
StringRef String) {
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, Attribute,
|
2015-05-25 00:40:47 +08:00
|
|
|
isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
|
|
|
|
DIEString(DU->getStringPool().getEntry(*Asm, String)));
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-08-03 04:44:46 +08:00
|
|
|
DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die,
|
|
|
|
dwarf::Attribute Attribute,
|
|
|
|
dwarf::Form Form,
|
|
|
|
const MCSymbol *Label) {
|
2015-06-26 07:46:41 +08:00
|
|
|
return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
|
2013-06-29 04:05:04 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
|
2013-10-22 01:28:37 +08:00
|
|
|
addLabel(Die, (dwarf::Attribute)0, Form, Label);
|
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
|
2013-12-10 07:32:48 +08:00
|
|
|
uint64_t Integer) {
|
2013-11-22 07:46:41 +08:00
|
|
|
if (DD->getDwarfVersion() >= 4)
|
|
|
|
addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
|
|
|
|
else
|
|
|
|
addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
|
|
|
|
}
|
|
|
|
|
2014-03-18 09:17:26 +08:00
|
|
|
unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
|
|
|
|
return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
|
|
|
|
: getCU().getOrCreateSourceID(FileName, DirName);
|
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
|
2013-01-19 06:11:33 +08:00
|
|
|
if (!DD->useSplitDwarf()) {
|
2013-10-22 01:28:37 +08:00
|
|
|
addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
|
|
|
|
addLabel(Die, dwarf::DW_FORM_udata, Sym);
|
2013-01-19 06:11:33 +08:00
|
|
|
} else {
|
2013-10-22 01:28:37 +08:00
|
|
|
addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
|
2014-04-24 05:04:59 +08:00
|
|
|
addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
|
2014-04-24 05:20:10 +08:00
|
|
|
DD->getAddressPool().getIndex(Sym));
|
2013-01-19 06:11:33 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
|
2014-03-07 09:30:55 +08:00
|
|
|
const MCSymbol *Hi, const MCSymbol *Lo) {
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4,
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
new (DIEValueAllocator) DIEDelta(Hi, Lo));
|
2014-03-07 09:30:55 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 03:33:43 +08:00
|
|
|
void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
addDIEEntry(Die, Attribute, DIEEntry(Entry));
|
2013-11-01 01:54:35 +08:00
|
|
|
}
|
|
|
|
|
2016-02-12 03:57:46 +08:00
|
|
|
void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) {
|
2014-04-27 00:26:41 +08:00
|
|
|
// Flag the type unit reference as a declaration so that if it contains
|
|
|
|
// members (implicit special members, static data member definitions, member
|
|
|
|
// declarations for definitions in this CU, etc) consumers don't get confused
|
|
|
|
// and think this is a full definition.
|
|
|
|
addFlag(Die, dwarf::DW_AT_declaration);
|
|
|
|
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
|
2016-02-12 03:57:46 +08:00
|
|
|
dwarf::DW_FORM_ref_sig8, DIEInteger(Signature));
|
2013-12-18 07:32:35 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
DIEEntry Entry) {
|
2016-12-02 02:56:29 +08:00
|
|
|
const DIEUnit *CU = Die.getUnit();
|
|
|
|
const DIEUnit *EntryCU = Entry.getEntry().getUnit();
|
|
|
|
if (!CU)
|
2013-11-01 01:54:35 +08:00
|
|
|
// We assume that Die belongs to this CU, if it is not linked to any CU yet.
|
2016-12-02 02:56:29 +08:00
|
|
|
CU = getUnitDie().getUnit();
|
2013-11-01 01:54:35 +08:00
|
|
|
if (!EntryCU)
|
2016-12-02 02:56:29 +08:00
|
|
|
EntryCU = getUnitDie().getUnit();
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, Attribute,
|
2016-12-02 02:56:29 +08:00
|
|
|
EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
|
2014-04-26 02:26:14 +08:00
|
|
|
Entry);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2016-04-30 00:07:55 +08:00
|
|
|
DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
|
2016-04-30 09:44:07 +08:00
|
|
|
DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
|
|
|
|
if (N)
|
|
|
|
insertDIE(N, &Die);
|
2013-10-29 08:53:03 +08:00
|
|
|
return Die;
|
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
|
2014-02-28 02:36:10 +08:00
|
|
|
Loc->ComputeSize(Asm);
|
2014-02-16 16:46:55 +08:00
|
|
|
DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, Attribute,
|
|
|
|
Loc->BestForm(DD->getDwarfVersion()), Loc);
|
2014-02-16 16:46:55 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
|
2013-12-10 07:32:48 +08:00
|
|
|
DIEBlock *Block) {
|
2014-02-28 02:36:10 +08:00
|
|
|
Block->ComputeSize(Asm);
|
2011-04-13 07:21:44 +08:00
|
|
|
DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
|
2015-06-26 07:46:41 +08:00
|
|
|
Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
|
2014-02-12 08:11:25 +08:00
|
|
|
StringRef Directory) {
|
2011-04-13 07:21:44 +08:00
|
|
|
if (Line == 0)
|
|
|
|
return;
|
2014-02-12 08:11:25 +08:00
|
|
|
|
2014-03-18 09:17:26 +08:00
|
|
|
unsigned FileID = getOrCreateSourceID(File, Directory);
|
2011-04-13 07:21:44 +08:00
|
|
|
assert(FileID && "Invalid file id");
|
2013-10-22 01:28:37 +08:00
|
|
|
addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
|
|
|
|
addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
|
2015-04-07 07:27:40 +08:00
|
|
|
assert(V);
|
2014-02-12 08:11:25 +08:00
|
|
|
|
2015-04-14 10:22:36 +08:00
|
|
|
addSourceLine(Die, V->getLine(), V->getScope()->getFilename(),
|
|
|
|
V->getScope()->getDirectory());
|
2014-02-12 08:11:25 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
|
2015-04-07 07:27:40 +08:00
|
|
|
assert(G);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2015-04-14 10:22:36 +08:00
|
|
|
addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory());
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
|
2015-04-07 07:27:40 +08:00
|
|
|
assert(SP);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory());
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
|
2015-04-07 07:27:40 +08:00
|
|
|
assert(Ty);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2015-04-16 09:01:28 +08:00
|
|
|
addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
|
2015-04-07 07:27:40 +08:00
|
|
|
assert(Ty);
|
2012-03-29 16:42:56 +08:00
|
|
|
|
2015-04-14 09:46:44 +08:00
|
|
|
addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
|
2012-03-29 16:42:56 +08:00
|
|
|
}
|
|
|
|
|
2011-04-13 07:21:44 +08:00
|
|
|
/* Byref variables, in Blocks, are declared by the programmer as "SomeType
|
|
|
|
VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
|
|
|
|
gives the variable VarName either the struct, or a pointer to the struct, as
|
|
|
|
its type. This is necessary for various behind-the-scenes things the
|
|
|
|
compiler needs to do with by-reference variables in Blocks.
|
|
|
|
|
|
|
|
However, as far as the original *programmer* is concerned, the variable
|
|
|
|
should still have type 'SomeType', as originally declared.
|
|
|
|
|
|
|
|
The function getBlockByrefType dives into the __Block_byref_x_VarName
|
|
|
|
struct to find the original type of the variable, which is then assigned to
|
|
|
|
the variable's Debug Information Entry as its real type. So far, so good.
|
|
|
|
However now the debugger will expect the variable VarName to have the type
|
|
|
|
SomeType. So we need the location attribute for the variable to be an
|
|
|
|
expression that explains to the debugger how to navigate through the
|
|
|
|
pointers and struct to find the actual variable of type SomeType.
|
|
|
|
|
|
|
|
The following function does just that. We start by getting
|
|
|
|
the "normal" location for the variable. This will be the location
|
|
|
|
of either the struct __Block_byref_x_VarName or the pointer to the
|
|
|
|
struct __Block_byref_x_VarName.
|
|
|
|
|
|
|
|
The struct will look something like:
|
|
|
|
|
|
|
|
struct __Block_byref_x_VarName {
|
|
|
|
... <various fields>
|
|
|
|
struct __Block_byref_x_VarName *forwarding;
|
|
|
|
... <various other fields>
|
|
|
|
SomeType VarName;
|
|
|
|
... <maybe more fields>
|
|
|
|
};
|
|
|
|
|
|
|
|
If we are given the struct directly (as our starting point) we
|
|
|
|
need to tell the debugger to:
|
|
|
|
|
|
|
|
1). Add the offset of the forwarding field.
|
|
|
|
|
|
|
|
2). Follow that pointer to get the real __Block_byref_x_VarName
|
|
|
|
struct to use (the real one may have been copied onto the heap).
|
|
|
|
|
|
|
|
3). Add the offset for the field VarName, to find the actual variable.
|
|
|
|
|
|
|
|
If we started with a pointer to the struct, then we need to
|
|
|
|
dereference that pointer first, before the other steps.
|
|
|
|
Translating this into DWARF ops, we will need to append the following
|
|
|
|
to the current location description for the variable:
|
|
|
|
|
|
|
|
DW_OP_deref -- optional, if we start with a pointer
|
|
|
|
DW_OP_plus_uconst <forward_fld_offset>
|
|
|
|
DW_OP_deref
|
|
|
|
DW_OP_plus_uconst <varName_fld_offset>
|
|
|
|
|
|
|
|
That is what this function does. */
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
|
2013-12-10 07:32:48 +08:00
|
|
|
dwarf::Attribute Attribute,
|
|
|
|
const MachineLocation &Location) {
|
2015-04-30 00:38:44 +08:00
|
|
|
const DIType *Ty = DV.getType();
|
|
|
|
const DIType *TmpTy = Ty;
|
2015-04-16 09:01:28 +08:00
|
|
|
uint16_t Tag = Ty->getTag();
|
2011-04-13 07:21:44 +08:00
|
|
|
bool isPointer = false;
|
|
|
|
|
2013-06-25 05:07:27 +08:00
|
|
|
StringRef varName = DV.getName();
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
if (Tag == dwarf::DW_TAG_pointer_type) {
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *DTy = cast<DIDerivedType>(Ty);
|
2015-04-16 09:01:28 +08:00
|
|
|
TmpTy = resolve(DTy->getBaseType());
|
2011-04-13 07:21:44 +08:00
|
|
|
isPointer = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find the __forwarding field and the variable field in the __Block_byref
|
|
|
|
// struct.
|
2015-07-25 02:17:17 +08:00
|
|
|
DINodeArray Fields = cast<DICompositeType>(TmpTy)->getElements();
|
2015-04-30 00:38:44 +08:00
|
|
|
const DIDerivedType *varField = nullptr;
|
|
|
|
const DIDerivedType *forwardingField = nullptr;
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2015-04-07 12:14:33 +08:00
|
|
|
for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *DT = cast<DIDerivedType>(Fields[i]);
|
2015-04-16 09:01:28 +08:00
|
|
|
StringRef fieldName = DT->getName();
|
2011-04-13 07:21:44 +08:00
|
|
|
if (fieldName == "__forwarding")
|
2013-11-19 07:33:32 +08:00
|
|
|
forwardingField = DT;
|
2011-04-13 07:21:44 +08:00
|
|
|
else if (fieldName == varName)
|
2013-11-19 07:33:32 +08:00
|
|
|
varField = DT;
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Get the offsets for the forwarding field and the variable field.
|
2015-04-16 09:01:28 +08:00
|
|
|
unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3;
|
|
|
|
unsigned varFieldOffset = varField->getOffsetInBits() >> 2;
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Decode the original location, and use that as the start of the byref
|
|
|
|
// variable's location.
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
|
2017-03-21 05:35:09 +08:00
|
|
|
DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
|
2017-04-20 07:42:25 +08:00
|
|
|
if (Location.isIndirect())
|
|
|
|
DwarfExpr.setMemoryLocationKind();
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2017-03-21 05:35:09 +08:00
|
|
|
SmallVector<uint64_t, 9> Ops;
|
2017-04-18 09:21:53 +08:00
|
|
|
if (Location.isIndirect() && Location.getOffset()) {
|
2017-03-21 05:35:09 +08:00
|
|
|
Ops.push_back(dwarf::DW_OP_plus);
|
|
|
|
Ops.push_back(Location.getOffset());
|
|
|
|
}
|
2011-04-13 07:21:44 +08:00
|
|
|
// If we started with a pointer to the __Block_byref... struct, then
|
|
|
|
// the first thing we need to do is dereference the pointer (DW_OP_deref).
|
|
|
|
if (isPointer)
|
2017-03-21 05:35:09 +08:00
|
|
|
Ops.push_back(dwarf::DW_OP_deref);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Next add the offset for the '__forwarding' field:
|
|
|
|
// DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
|
|
|
|
// adding the offset if it's 0.
|
|
|
|
if (forwardingFieldOffset > 0) {
|
2017-03-21 05:35:09 +08:00
|
|
|
Ops.push_back(dwarf::DW_OP_plus);
|
|
|
|
Ops.push_back(forwardingFieldOffset);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Now dereference the __forwarding field to get to the real __Block_byref
|
|
|
|
// struct: DW_OP_deref.
|
2017-03-21 05:35:09 +08:00
|
|
|
Ops.push_back(dwarf::DW_OP_deref);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Now that we've got the real __Block_byref... struct, add the offset
|
|
|
|
// for the variable's field to get to the location of the actual variable:
|
|
|
|
// DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
|
|
|
|
if (varFieldOffset > 0) {
|
2017-03-21 05:35:09 +08:00
|
|
|
Ops.push_back(dwarf::DW_OP_plus);
|
|
|
|
Ops.push_back(varFieldOffset);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
2017-03-21 05:35:09 +08:00
|
|
|
|
|
|
|
DIExpressionCursor Cursor(Ops);
|
|
|
|
const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
|
2017-04-20 07:42:25 +08:00
|
|
|
if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
|
2017-03-21 05:35:09 +08:00
|
|
|
return;
|
|
|
|
DwarfExpr.addExpression(std::move(Cursor));
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Now attach the location information to the DIE.
|
2017-03-21 05:35:09 +08:00
|
|
|
addBlock(Die, Attribute, DwarfExpr.finalize());
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2013-10-05 09:43:03 +08:00
|
|
|
/// Return true if type encoding is unsigned.
|
2015-04-30 00:38:44 +08:00
|
|
|
static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
|
2015-07-25 03:42:12 +08:00
|
|
|
if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
|
|
|
|
// FIXME: Enums without a fixed underlying type have unknown signedness
|
|
|
|
// here, leading to incorrectly emitted constants.
|
|
|
|
if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// (Pieces of) aggregate types that get hacked apart by SROA may be
|
|
|
|
// represented by a constant. Encode them as unsigned bytes.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
|
2015-04-16 09:01:28 +08:00
|
|
|
dwarf::Tag T = (dwarf::Tag)Ty->getTag();
|
2014-05-21 02:21:51 +08:00
|
|
|
// Encode pointer constants as unsigned bytes. This is used at least for
|
2014-05-21 05:40:13 +08:00
|
|
|
// null pointer constant emission.
|
|
|
|
// FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
|
|
|
|
// here, but accept them for now due to a bug in SROA producing bogus
|
|
|
|
// dbg.values.
|
2015-07-25 03:42:12 +08:00
|
|
|
if (T == dwarf::DW_TAG_pointer_type ||
|
2014-05-21 05:40:13 +08:00
|
|
|
T == dwarf::DW_TAG_ptr_to_member_type ||
|
|
|
|
T == dwarf::DW_TAG_reference_type ||
|
2015-07-25 03:42:12 +08:00
|
|
|
T == dwarf::DW_TAG_rvalue_reference_type)
|
2014-05-21 02:21:51 +08:00
|
|
|
return true;
|
|
|
|
assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
|
|
|
|
T == dwarf::DW_TAG_volatile_type ||
|
2016-11-01 03:09:38 +08:00
|
|
|
T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
|
2015-07-25 03:42:12 +08:00
|
|
|
DITypeRef Deriv = DTy->getBaseType();
|
|
|
|
assert(Deriv && "Expected valid base type");
|
|
|
|
return isUnsignedDIType(DD, DD->resolve(Deriv));
|
2014-05-12 01:04:05 +08:00
|
|
|
}
|
2013-10-05 09:43:03 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *BTy = cast<DIBasicType>(Ty);
|
2015-04-16 09:01:28 +08:00
|
|
|
unsigned Encoding = BTy->getEncoding();
|
2014-05-12 14:08:18 +08:00
|
|
|
assert((Encoding == dwarf::DW_ATE_unsigned ||
|
|
|
|
Encoding == dwarf::DW_ATE_unsigned_char ||
|
|
|
|
Encoding == dwarf::DW_ATE_signed ||
|
|
|
|
Encoding == dwarf::DW_ATE_signed_char ||
|
2015-04-16 09:01:28 +08:00
|
|
|
Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
|
|
|
|
Encoding == dwarf::DW_ATE_boolean ||
|
|
|
|
(Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
|
|
|
|
Ty->getName() == "decltype(nullptr)")) &&
|
2014-05-17 05:53:09 +08:00
|
|
|
"Unsupported encoding");
|
2015-04-16 09:01:28 +08:00
|
|
|
return Encoding == dwarf::DW_ATE_unsigned ||
|
|
|
|
Encoding == dwarf::DW_ATE_unsigned_char ||
|
|
|
|
Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
|
|
|
|
Ty->getTag() == dwarf::DW_TAG_unspecified_type;
|
2013-10-05 09:43:03 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
|
2013-10-19 09:04:47 +08:00
|
|
|
assert(MO.isFPImm() && "Invalid machine operand!");
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
|
2011-04-13 07:21:44 +08:00
|
|
|
APFloat FPImm = MO.getFPImm()->getValueAPF();
|
|
|
|
|
|
|
|
// Get the raw data form of the floating point.
|
|
|
|
const APInt FltVal = FPImm.bitcastToAPInt();
|
2013-10-19 09:04:47 +08:00
|
|
|
const char *FltPtr = (const char *)FltVal.getRawData();
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
|
2012-10-09 00:38:25 +08:00
|
|
|
bool LittleEndian = Asm->getDataLayout().isLittleEndian();
|
2011-04-13 07:21:44 +08:00
|
|
|
int Incr = (LittleEndian ? 1 : -1);
|
|
|
|
int Start = (LittleEndian ? 0 : NumBytes - 1);
|
|
|
|
int Stop = (LittleEndian ? NumBytes : -1);
|
|
|
|
|
|
|
|
// Output the constant to DWARF one byte at a time.
|
|
|
|
for (; Start != Stop; Start += Incr)
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2013-10-22 01:28:37 +08:00
|
|
|
addBlock(Die, dwarf::DW_AT_const_value, Block);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
|
2013-08-28 07:49:04 +08:00
|
|
|
// Pass this down to addConstantValue as an unsigned bag of bits.
|
|
|
|
addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
|
2013-01-20 09:18:01 +08:00
|
|
|
}
|
|
|
|
|
2015-04-21 02:52:06 +08:00
|
|
|
void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
|
2015-04-30 00:38:44 +08:00
|
|
|
const DIType *Ty) {
|
2014-05-11 23:56:59 +08:00
|
|
|
addConstantValue(Die, CI->getValue(), Ty);
|
2013-01-20 09:18:01 +08:00
|
|
|
}
|
|
|
|
|
2014-05-11 23:47:39 +08:00
|
|
|
void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
|
2015-04-30 00:38:44 +08:00
|
|
|
const DIType *Ty) {
|
2014-05-11 23:47:39 +08:00
|
|
|
assert(MO.isImm() && "Invalid machine operand!");
|
|
|
|
|
2014-05-12 00:08:41 +08:00
|
|
|
addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
|
2014-05-11 23:47:39 +08:00
|
|
|
}
|
|
|
|
|
2014-05-12 00:08:41 +08:00
|
|
|
void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
|
2014-05-11 23:47:39 +08:00
|
|
|
// FIXME: This is a bit conservative/simple - it emits negative values always
|
|
|
|
// sign extended to 64 bits rather than minimizing the number of bytes.
|
|
|
|
addUInt(Die, dwarf::DW_AT_const_value,
|
2014-05-12 00:08:41 +08:00
|
|
|
Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
|
2014-05-11 23:47:39 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
|
2014-05-11 23:56:59 +08:00
|
|
|
addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
|
|
|
|
}
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
|
2013-01-20 09:18:01 +08:00
|
|
|
unsigned CIBitWidth = Val.getBitWidth();
|
2011-05-28 08:39:18 +08:00
|
|
|
if (CIBitWidth <= 64) {
|
2014-05-12 00:08:41 +08:00
|
|
|
addConstantValue(Die, Unsigned,
|
|
|
|
Unsigned ? Val.getZExtValue() : Val.getSExtValue());
|
2013-07-03 09:08:30 +08:00
|
|
|
return;
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Get the raw data form of the large APInt.
|
2011-10-28 22:12:22 +08:00
|
|
|
const uint64_t *Ptr64 = Val.getRawData();
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
|
2012-10-09 00:38:25 +08:00
|
|
|
bool LittleEndian = Asm->getDataLayout().isLittleEndian();
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Output the constant to DWARF one byte at a time.
|
2011-10-28 22:12:22 +08:00
|
|
|
for (int i = 0; i < NumBytes; i++) {
|
|
|
|
uint8_t c;
|
|
|
|
if (LittleEndian)
|
|
|
|
c = Ptr64[i / 8] >> (8 * (i & 7));
|
|
|
|
else
|
|
|
|
c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(*Block, dwarf::DW_FORM_data1, c);
|
2011-10-28 22:12:22 +08:00
|
|
|
}
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2013-10-22 01:28:37 +08:00
|
|
|
addBlock(Die, dwarf::DW_AT_const_value, Block);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-03-11 06:44:45 +08:00
|
|
|
void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
|
2016-04-19 06:41:41 +08:00
|
|
|
if (!LinkageName.empty())
|
2015-03-11 06:44:45 +08:00
|
|
|
addString(Die,
|
|
|
|
DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
|
|
|
|
: dwarf::DW_AT_MIPS_linkage_name,
|
|
|
|
GlobalValue::getRealLinkageName(LinkageName));
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
|
2011-04-13 07:21:44 +08:00
|
|
|
// Add template parameters.
|
2015-04-18 08:35:36 +08:00
|
|
|
for (const auto *Element : TParams) {
|
2015-04-30 00:38:44 +08:00
|
|
|
if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
|
2015-04-07 07:27:40 +08:00
|
|
|
constructTemplateTypeParameterDIE(Buffer, TTP);
|
2015-04-30 00:38:44 +08:00
|
|
|
else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
|
2015-04-07 07:27:40 +08:00
|
|
|
constructTemplateValueParameterDIE(Buffer, TVP);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
}
|
2011-10-27 06:55:33 +08:00
|
|
|
|
2017-04-27 06:56:44 +08:00
|
|
|
/// Add thrown types.
|
|
|
|
void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
|
|
|
|
for (const auto *Ty : ThrownTypes) {
|
|
|
|
DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
|
|
|
|
addType(TT, cast<DIType>(Ty));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
|
|
|
|
if (!Context || isa<DIFile>(Context))
|
2014-04-26 02:35:57 +08:00
|
|
|
return &getUnitDie();
|
2015-04-30 00:38:44 +08:00
|
|
|
if (auto *T = dyn_cast<DIType>(Context))
|
2015-04-07 07:27:40 +08:00
|
|
|
return getOrCreateTypeDIE(T);
|
2015-04-30 00:38:44 +08:00
|
|
|
if (auto *NS = dyn_cast<DINamespace>(Context))
|
2015-04-07 07:27:40 +08:00
|
|
|
return getOrCreateNameSpace(NS);
|
2015-04-30 00:38:44 +08:00
|
|
|
if (auto *SP = dyn_cast<DISubprogram>(Context))
|
2015-04-07 07:27:40 +08:00
|
|
|
return getOrCreateSubprogramDIE(SP);
|
2015-09-11 01:13:58 +08:00
|
|
|
if (auto *M = dyn_cast<DIModule>(Context))
|
|
|
|
return getOrCreateModule(M);
|
2013-11-16 05:05:09 +08:00
|
|
|
return getDIE(Context);
|
2013-01-16 09:22:23 +08:00
|
|
|
}
|
|
|
|
|
2017-02-03 08:44:18 +08:00
|
|
|
DIE *DwarfTypeUnit::createTypeDIE(const DICompositeType *Ty) {
|
2015-04-21 02:32:29 +08:00
|
|
|
auto *Context = resolve(Ty->getScope());
|
2013-11-26 08:15:27 +08:00
|
|
|
DIE *ContextDIE = getOrCreateContextDIE(Context);
|
2013-11-20 07:08:21 +08:00
|
|
|
|
2014-04-26 02:52:29 +08:00
|
|
|
if (DIE *TyDIE = getDIE(Ty))
|
2013-11-20 07:08:21 +08:00
|
|
|
return TyDIE;
|
|
|
|
|
|
|
|
// Create new type.
|
2015-04-16 09:01:28 +08:00
|
|
|
DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
|
2013-11-20 07:08:21 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
|
2013-11-20 07:08:21 +08:00
|
|
|
|
2017-03-14 06:56:14 +08:00
|
|
|
updateAcceleratorTables(Context, Ty, TyDIE);
|
2014-04-26 02:52:29 +08:00
|
|
|
return &TyDIE;
|
2013-11-20 07:08:21 +08:00
|
|
|
}
|
|
|
|
|
2015-07-02 02:07:16 +08:00
|
|
|
DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
|
2013-11-15 06:25:02 +08:00
|
|
|
if (!TyNode)
|
2014-04-24 14:44:33 +08:00
|
|
|
return nullptr;
|
2013-10-30 06:49:29 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *Ty = cast<DIType>(TyNode);
|
2013-11-15 06:25:02 +08:00
|
|
|
|
2014-04-12 13:35:59 +08:00
|
|
|
// DW_TAG_restrict_type is not supported in DWARF2
|
2015-04-16 09:01:28 +08:00
|
|
|
if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
|
2015-07-02 02:07:16 +08:00
|
|
|
return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
|
2014-04-12 13:35:59 +08:00
|
|
|
|
2016-11-01 03:09:38 +08:00
|
|
|
// DW_TAG_atomic_type is not supported in DWARF < 5
|
|
|
|
if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
|
|
|
|
return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
|
|
|
|
|
2013-10-30 06:49:29 +08:00
|
|
|
// Construct the context before querying for the existence of the DIE in case
|
|
|
|
// such construction creates the DIE.
|
2015-04-21 02:32:29 +08:00
|
|
|
auto *Context = resolve(Ty->getScope());
|
2016-04-30 09:44:07 +08:00
|
|
|
DIE *ContextDIE = getOrCreateContextDIE(Context);
|
|
|
|
assert(ContextDIE);
|
2013-10-30 06:49:29 +08:00
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
if (DIE *TyDIE = getDIE(Ty))
|
2011-04-13 07:21:44 +08:00
|
|
|
return TyDIE;
|
|
|
|
|
2016-04-30 09:44:07 +08:00
|
|
|
// Create new type.
|
|
|
|
DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
|
2013-10-30 06:49:29 +08:00
|
|
|
|
2014-04-26 02:52:29 +08:00
|
|
|
updateAcceleratorTables(Context, Ty, TyDIE);
|
2014-03-06 09:42:00 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
if (auto *BT = dyn_cast<DIBasicType>(Ty))
|
2015-04-07 07:27:40 +08:00
|
|
|
constructTypeDIE(TyDIE, BT);
|
2015-04-30 00:38:44 +08:00
|
|
|
else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
|
2015-04-21 05:04:33 +08:00
|
|
|
constructTypeDIE(TyDIE, STy);
|
2015-04-30 00:38:44 +08:00
|
|
|
else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
|
2015-04-16 09:01:28 +08:00
|
|
|
if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
|
|
|
|
if (MDString *TypeId = CTy->getRawIdentifier()) {
|
2014-02-12 08:31:30 +08:00
|
|
|
DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
|
2014-03-15 07:08:17 +08:00
|
|
|
// Skip updating the accelerator tables since this is not the full type.
|
2014-04-26 02:26:14 +08:00
|
|
|
return &TyDIE;
|
2014-01-04 02:59:42 +08:00
|
|
|
}
|
2014-04-26 02:26:14 +08:00
|
|
|
constructTypeDIE(TyDIE, CTy);
|
2013-11-26 08:22:37 +08:00
|
|
|
} else {
|
2015-04-30 00:38:44 +08:00
|
|
|
constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
2013-11-20 06:51:04 +08:00
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
return &TyDIE;
|
2013-11-20 06:51:04 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
|
|
|
|
const DIType *Ty, const DIE &TyDIE) {
|
2015-04-16 09:01:28 +08:00
|
|
|
if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
|
2016-08-25 08:45:04 +08:00
|
|
|
bool IsImplementation = false;
|
2015-07-25 04:45:26 +08:00
|
|
|
if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
|
2012-01-07 07:03:37 +08:00
|
|
|
// A runtime language of 0 actually means C/C++ and that any
|
|
|
|
// non-negative value is some version of Objective-C/C++.
|
2015-04-16 09:01:28 +08:00
|
|
|
IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
|
2012-01-06 12:35:23 +08:00
|
|
|
}
|
2013-09-06 02:20:16 +08:00
|
|
|
unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
|
2015-04-16 09:01:28 +08:00
|
|
|
DD->addAccelType(Ty->getName(), TyDIE, Flags);
|
2013-11-26 08:15:27 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
|
|
|
|
isa<DINamespace>(Context))
|
2014-11-02 14:06:14 +08:00
|
|
|
addGlobalType(Ty, TyDIE, Context);
|
2012-01-06 12:35:23 +08:00
|
|
|
}
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
|
2015-04-21 02:52:06 +08:00
|
|
|
dwarf::Attribute Attribute) {
|
2013-08-08 15:40:37 +08:00
|
|
|
assert(Ty && "Trying to add a type that doesn't exist?");
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
|
2011-06-01 07:30:30 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
|
2013-10-17 10:06:06 +08:00
|
|
|
if (!Context)
|
|
|
|
return "";
|
|
|
|
|
|
|
|
// FIXME: Decide whether to implement this for non-C++ languages.
|
|
|
|
if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
|
|
|
|
return "";
|
|
|
|
|
2013-10-19 09:04:42 +08:00
|
|
|
std::string CS;
|
2015-04-30 00:38:44 +08:00
|
|
|
SmallVector<const DIScope *, 1> Parents;
|
|
|
|
while (!isa<DICompileUnit>(Context)) {
|
2013-10-17 10:06:06 +08:00
|
|
|
Parents.push_back(Context);
|
2015-04-16 09:37:00 +08:00
|
|
|
if (Context->getScope())
|
|
|
|
Context = resolve(Context->getScope());
|
2013-10-17 10:06:06 +08:00
|
|
|
else
|
|
|
|
// Structure, etc types will have a NULL context if they're at the top
|
|
|
|
// level.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reverse iterate over our list to go from the outermost construct to the
|
|
|
|
// innermost.
|
2015-07-25 05:13:43 +08:00
|
|
|
for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
|
2015-04-16 09:37:00 +08:00
|
|
|
StringRef Name = Ctx->getName();
|
2015-04-30 00:38:44 +08:00
|
|
|
if (Name.empty() && isa<DINamespace>(Ctx))
|
2014-06-07 06:16:56 +08:00
|
|
|
Name = "(anonymous namespace)";
|
2013-10-19 09:04:42 +08:00
|
|
|
if (!Name.empty()) {
|
2013-10-17 10:06:06 +08:00
|
|
|
CS += Name;
|
|
|
|
CS += "::";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return CS;
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
|
2011-04-13 07:21:44 +08:00
|
|
|
// Get core information.
|
2015-04-16 09:01:28 +08:00
|
|
|
StringRef Name = BTy->getName();
|
2011-04-13 07:21:44 +08:00
|
|
|
// Add name if not anonymous or intermediate type.
|
|
|
|
if (!Name.empty())
|
2014-04-26 02:26:14 +08:00
|
|
|
addString(Buffer, dwarf::DW_AT_name, Name);
|
2011-09-15 07:13:28 +08:00
|
|
|
|
2013-10-05 07:21:16 +08:00
|
|
|
// An unspecified type only has a name attribute.
|
2015-04-16 09:01:28 +08:00
|
|
|
if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
|
2011-09-15 07:13:28 +08:00
|
|
|
return;
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
|
2015-04-16 09:01:28 +08:00
|
|
|
BTy->getEncoding());
|
2011-09-15 07:13:28 +08:00
|
|
|
|
2015-04-16 09:01:28 +08:00
|
|
|
uint64_t Size = BTy->getSizeInBits() >> 3;
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
|
2011-04-13 07:21:44 +08:00
|
|
|
// Get core information.
|
2015-04-16 09:01:28 +08:00
|
|
|
StringRef Name = DTy->getName();
|
|
|
|
uint64_t Size = DTy->getSizeInBits() >> 3;
|
2013-10-05 07:21:16 +08:00
|
|
|
uint16_t Tag = Buffer.getTag();
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Map to main type, void will not have a type.
|
2015-04-30 00:38:44 +08:00
|
|
|
const DIType *FromTy = resolve(DTy->getBaseType());
|
2013-08-08 15:40:37 +08:00
|
|
|
if (FromTy)
|
2014-04-26 02:26:14 +08:00
|
|
|
addType(Buffer, FromTy);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Add name if not anonymous or intermediate type.
|
|
|
|
if (!Name.empty())
|
2014-04-26 02:26:14 +08:00
|
|
|
addString(Buffer, dwarf::DW_AT_name, Name);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Add size if non-zero (derived types might be zero-sized.)
|
2014-12-24 09:17:51 +08:00
|
|
|
if (Size && Tag != dwarf::DW_TAG_pointer_type
|
2015-11-16 15:57:32 +08:00
|
|
|
&& Tag != dwarf::DW_TAG_ptr_to_member_type
|
|
|
|
&& Tag != dwarf::DW_TAG_reference_type
|
|
|
|
&& Tag != dwarf::DW_TAG_rvalue_reference_type)
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2013-01-07 13:51:15 +08:00
|
|
|
if (Tag == dwarf::DW_TAG_ptr_to_member_type)
|
2015-04-16 07:49:09 +08:00
|
|
|
addDIEEntry(
|
|
|
|
Buffer, dwarf::DW_AT_containing_type,
|
2015-04-30 00:38:44 +08:00
|
|
|
*getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
|
2011-04-13 07:21:44 +08:00
|
|
|
// Add source line info if available and TyDesc is not a forward declaration.
|
2015-04-16 09:01:28 +08:00
|
|
|
if (!DTy->isForwardDecl())
|
2014-04-26 02:26:14 +08:00
|
|
|
addSourceLine(Buffer, DTy);
|
2017-03-09 07:55:44 +08:00
|
|
|
|
|
|
|
// If DWARF address space value is other than None, add it for pointer and
|
|
|
|
// reference types as DW_AT_address_class.
|
|
|
|
if (DTy->getDWARFAddressSpace() && (Tag == dwarf::DW_TAG_pointer_type ||
|
|
|
|
Tag == dwarf::DW_TAG_reference_type))
|
|
|
|
addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
|
|
|
|
DTy->getDWARFAddressSpace().getValue());
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
|
2015-04-07 12:14:33 +08:00
|
|
|
for (unsigned i = 1, N = Args.size(); i < N; ++i) {
|
2015-04-30 00:38:44 +08:00
|
|
|
const DIType *Ty = resolve(Args[i]);
|
2014-07-30 02:20:39 +08:00
|
|
|
if (!Ty) {
|
2014-02-26 06:27:14 +08:00
|
|
|
assert(i == N-1 && "Unspecified parameter must be the last argument");
|
|
|
|
createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
|
|
|
|
} else {
|
2014-04-26 02:52:29 +08:00
|
|
|
DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
|
2014-10-27 07:37:04 +08:00
|
|
|
addType(Arg, Ty);
|
2015-04-16 09:01:28 +08:00
|
|
|
if (Ty->isArtificial())
|
2014-04-26 02:52:29 +08:00
|
|
|
addFlag(Arg, dwarf::DW_AT_artificial);
|
2014-02-26 03:57:42 +08:00
|
|
|
}
|
2014-02-26 06:27:14 +08:00
|
|
|
}
|
2014-02-26 03:57:42 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
|
2015-04-21 05:04:33 +08:00
|
|
|
// Add return type. A void return won't have a type.
|
2015-04-30 00:38:44 +08:00
|
|
|
auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
|
2015-04-21 05:04:33 +08:00
|
|
|
if (Elements.size())
|
|
|
|
if (auto RTy = resolve(Elements[0]))
|
|
|
|
addType(Buffer, RTy);
|
|
|
|
|
|
|
|
bool isPrototyped = true;
|
|
|
|
if (Elements.size() == 2 && !Elements[1])
|
|
|
|
isPrototyped = false;
|
|
|
|
|
|
|
|
constructSubprogramArguments(Buffer, Elements);
|
|
|
|
|
|
|
|
// Add prototype flag if we're dealing with a C language and the function has
|
|
|
|
// been prototyped.
|
|
|
|
uint16_t Language = getLanguage();
|
|
|
|
if (isPrototyped &&
|
|
|
|
(Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
|
|
|
|
Language == dwarf::DW_LANG_ObjC))
|
|
|
|
addFlag(Buffer, dwarf::DW_AT_prototyped);
|
|
|
|
|
2016-06-09 04:34:29 +08:00
|
|
|
// Add a DW_AT_calling_convention if this has an explicit convention.
|
|
|
|
if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
|
|
|
|
addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
|
|
|
|
CTy->getCC());
|
|
|
|
|
2015-04-21 05:04:33 +08:00
|
|
|
if (CTy->isLValueReference())
|
|
|
|
addFlag(Buffer, dwarf::DW_AT_reference);
|
|
|
|
|
|
|
|
if (CTy->isRValueReference())
|
|
|
|
addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
|
2013-11-20 07:08:21 +08:00
|
|
|
// Add name if not anonymous or intermediate type.
|
2015-04-16 09:01:28 +08:00
|
|
|
StringRef Name = CTy->getName();
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2015-04-16 09:01:28 +08:00
|
|
|
uint64_t Size = CTy->getSizeInBits() >> 3;
|
2013-10-05 07:21:16 +08:00
|
|
|
uint16_t Tag = Buffer.getTag();
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
switch (Tag) {
|
|
|
|
case dwarf::DW_TAG_array_type:
|
2013-11-12 02:52:31 +08:00
|
|
|
constructArrayTypeDIE(Buffer, CTy);
|
2011-04-13 07:21:44 +08:00
|
|
|
break;
|
2013-11-12 02:52:39 +08:00
|
|
|
case dwarf::DW_TAG_enumeration_type:
|
|
|
|
constructEnumTypeDIE(Buffer, CTy);
|
|
|
|
break;
|
2011-04-13 07:21:44 +08:00
|
|
|
case dwarf::DW_TAG_structure_type:
|
|
|
|
case dwarf::DW_TAG_union_type:
|
|
|
|
case dwarf::DW_TAG_class_type: {
|
|
|
|
// Add elements to structure type.
|
2015-04-30 00:38:44 +08:00
|
|
|
DINodeArray Elements = CTy->getElements();
|
2015-04-18 08:35:36 +08:00
|
|
|
for (const auto *Element : Elements) {
|
2015-04-07 07:27:40 +08:00
|
|
|
if (!Element)
|
|
|
|
continue;
|
2015-04-30 00:38:44 +08:00
|
|
|
if (auto *SP = dyn_cast<DISubprogram>(Element))
|
2015-04-07 07:27:40 +08:00
|
|
|
getOrCreateSubprogramDIE(SP);
|
2015-04-30 00:38:44 +08:00
|
|
|
else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
|
2015-04-16 09:01:28 +08:00
|
|
|
if (DDTy->getTag() == dwarf::DW_TAG_friend) {
|
2014-04-26 02:52:29 +08:00
|
|
|
DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
|
2015-04-16 09:01:28 +08:00
|
|
|
addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
|
|
|
|
} else if (DDTy->isStaticMember()) {
|
2013-10-24 06:57:12 +08:00
|
|
|
getOrCreateStaticMemberDIE(DDTy);
|
2013-10-15 04:33:57 +08:00
|
|
|
} else {
|
2013-10-24 07:00:44 +08:00
|
|
|
constructMemberDIE(Buffer, DDTy);
|
2013-10-15 04:33:57 +08:00
|
|
|
}
|
2015-04-30 00:38:44 +08:00
|
|
|
} else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
|
2015-04-14 09:46:44 +08:00
|
|
|
DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
|
|
|
|
StringRef PropertyName = Property->getName();
|
2012-02-08 07:33:58 +08:00
|
|
|
addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
|
2015-04-14 09:46:44 +08:00
|
|
|
if (Property->getType())
|
2015-06-16 07:18:03 +08:00
|
|
|
addType(ElemDie, resolve(Property->getType()));
|
2012-05-23 02:45:24 +08:00
|
|
|
addSourceLine(ElemDie, Property);
|
2015-04-14 09:46:44 +08:00
|
|
|
StringRef GetterName = Property->getGetterName();
|
2012-02-08 07:33:58 +08:00
|
|
|
if (!GetterName.empty())
|
|
|
|
addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
|
2015-04-14 09:46:44 +08:00
|
|
|
StringRef SetterName = Property->getSetterName();
|
2012-02-08 07:33:58 +08:00
|
|
|
if (!SetterName.empty())
|
|
|
|
addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
|
2015-04-14 09:46:44 +08:00
|
|
|
if (unsigned PropertyAttributes = Property->getAttributes())
|
2013-10-22 01:28:37 +08:00
|
|
|
addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
|
2013-10-19 09:04:47 +08:00
|
|
|
PropertyAttributes);
|
2015-04-07 07:27:40 +08:00
|
|
|
}
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-16 09:01:28 +08:00
|
|
|
if (CTy->isAppleBlockExtension())
|
2014-04-26 02:26:14 +08:00
|
|
|
addFlag(Buffer, dwarf::DW_AT_APPLE_block);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2014-12-19 08:01:20 +08:00
|
|
|
// This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
|
|
|
|
// inside C++ composite types to point to the base class with the vtable.
|
2015-04-21 05:17:32 +08:00
|
|
|
if (auto *ContainingType =
|
2015-04-30 00:38:44 +08:00
|
|
|
dyn_cast_or_null<DICompositeType>(resolve(CTy->getVTableHolder())))
|
2014-04-26 02:26:14 +08:00
|
|
|
addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
|
2014-04-26 03:33:43 +08:00
|
|
|
*getOrCreateTypeDIE(ContainingType));
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2015-04-16 09:01:28 +08:00
|
|
|
if (CTy->isObjcClassComplete())
|
2014-04-26 02:26:14 +08:00
|
|
|
addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
|
2011-05-13 03:06:16 +08:00
|
|
|
|
2011-12-17 07:42:42 +08:00
|
|
|
// Add template parameters to a class, structure or union types.
|
|
|
|
// FIXME: The support isn't in the metadata for this yet.
|
|
|
|
if (Tag == dwarf::DW_TAG_class_type ||
|
2013-10-19 09:04:47 +08:00
|
|
|
Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
|
2015-04-16 09:01:28 +08:00
|
|
|
addTemplateParams(Buffer, CTy->getTemplateParams());
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add name if not anonymous or intermediate type.
|
|
|
|
if (!Name.empty())
|
2014-04-26 02:26:14 +08:00
|
|
|
addString(Buffer, dwarf::DW_AT_name, Name);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2012-05-23 02:45:18 +08:00
|
|
|
if (Tag == dwarf::DW_TAG_enumeration_type ||
|
2013-10-19 09:04:47 +08:00
|
|
|
Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
|
2012-05-23 02:45:18 +08:00
|
|
|
Tag == dwarf::DW_TAG_union_type) {
|
2011-04-13 07:21:44 +08:00
|
|
|
// Add size if non-zero (derived types might be zero-sized.)
|
2012-06-01 08:22:32 +08:00
|
|
|
// TODO: Do we care about size for enum forward declarations?
|
2011-04-13 07:21:44 +08:00
|
|
|
if (Size)
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
|
2015-04-16 09:01:28 +08:00
|
|
|
else if (!CTy->isForwardDecl())
|
2011-04-13 07:21:44 +08:00
|
|
|
// Add zero size if it is not a forward declaration.
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
|
2012-06-01 08:22:32 +08:00
|
|
|
|
|
|
|
// If we're a forward decl, say so.
|
2015-04-16 09:01:28 +08:00
|
|
|
if (CTy->isForwardDecl())
|
2014-04-26 02:26:14 +08:00
|
|
|
addFlag(Buffer, dwarf::DW_AT_declaration);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Add source line info if available.
|
2015-04-16 09:01:28 +08:00
|
|
|
if (!CTy->isForwardDecl())
|
2014-04-26 02:26:14 +08:00
|
|
|
addSourceLine(Buffer, CTy);
|
2012-03-07 08:15:19 +08:00
|
|
|
|
|
|
|
// No harm in adding the runtime language to the declaration.
|
2015-04-16 09:01:28 +08:00
|
|
|
unsigned RLang = CTy->getRuntimeLang();
|
2012-03-07 08:15:19 +08:00
|
|
|
if (RLang)
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
|
2013-10-19 09:04:47 +08:00
|
|
|
RLang);
|
2016-10-26 19:59:03 +08:00
|
|
|
|
|
|
|
// Add align info if available.
|
2016-10-27 05:32:29 +08:00
|
|
|
if (uint32_t AlignInBytes = CTy->getAlignInBytes())
|
2016-10-26 19:59:03 +08:00
|
|
|
addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
|
|
|
|
AlignInBytes);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-22 02:44:06 +08:00
|
|
|
void DwarfUnit::constructTemplateTypeParameterDIE(
|
2015-04-30 00:38:44 +08:00
|
|
|
DIE &Buffer, const DITemplateTypeParameter *TP) {
|
2014-04-26 02:26:14 +08:00
|
|
|
DIE &ParamDIE =
|
2014-04-26 02:52:29 +08:00
|
|
|
createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
|
2013-08-08 16:09:43 +08:00
|
|
|
// Add the type if it exists, it could be void and therefore no type.
|
2015-04-14 11:01:27 +08:00
|
|
|
if (TP->getType())
|
|
|
|
addType(ParamDIE, resolve(TP->getType()));
|
|
|
|
if (!TP->getName().empty())
|
|
|
|
addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-22 02:44:06 +08:00
|
|
|
void DwarfUnit::constructTemplateValueParameterDIE(
|
2015-04-30 00:38:44 +08:00
|
|
|
DIE &Buffer, const DITemplateValueParameter *VP) {
|
2015-04-14 11:01:27 +08:00
|
|
|
DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
|
2013-08-08 15:40:37 +08:00
|
|
|
|
|
|
|
// Add the type if there is one, template template and template parameter
|
|
|
|
// packs will not have a type.
|
2015-04-14 11:01:27 +08:00
|
|
|
if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
|
|
|
|
addType(ParamDIE, resolve(VP->getType()));
|
|
|
|
if (!VP->getName().empty())
|
|
|
|
addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
|
|
|
|
if (Metadata *Val = VP->getValue()) {
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
|
2015-04-14 11:01:27 +08:00
|
|
|
addConstantValue(ParamDIE, CI, resolve(VP->getType()));
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
|
2016-07-10 04:47:48 +08:00
|
|
|
// We cannot describe the location of dllimport'd entities: the
|
|
|
|
// computation of their address requires loads from the IAT.
|
|
|
|
if (!GV->hasDLLImportStorageClass()) {
|
|
|
|
// For declaration non-type template parameters (such as global values
|
|
|
|
// and functions)
|
|
|
|
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
|
|
|
|
addOpAddress(*Loc, Asm->getSymbol(GV));
|
|
|
|
// Emit DW_OP_stack_value to use the address as the immediate value of
|
|
|
|
// the parameter, rather than a pointer to it.
|
|
|
|
addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
|
|
|
|
addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
|
|
|
|
}
|
2015-04-14 11:01:27 +08:00
|
|
|
} else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
|
2013-06-23 02:59:11 +08:00
|
|
|
assert(isa<MDString>(Val));
|
|
|
|
addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
|
|
|
|
cast<MDString>(Val)->getString());
|
2015-04-14 11:01:27 +08:00
|
|
|
} else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
|
2015-04-07 12:14:33 +08:00
|
|
|
addTemplateParams(ParamDIE, cast<MDTuple>(Val));
|
2013-05-11 05:52:07 +08:00
|
|
|
}
|
|
|
|
}
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
|
2013-10-29 13:49:41 +08:00
|
|
|
// Construct the context before querying for the existence of the DIE in case
|
|
|
|
// such construction creates the DIE.
|
2015-04-14 11:01:27 +08:00
|
|
|
DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
|
2013-10-29 13:49:41 +08:00
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
if (DIE *NDie = getDIE(NS))
|
2011-05-07 00:57:54 +08:00
|
|
|
return NDie;
|
2014-04-26 02:52:29 +08:00
|
|
|
DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
|
2013-10-29 13:49:41 +08:00
|
|
|
|
2015-04-14 11:01:27 +08:00
|
|
|
StringRef Name = NS->getName();
|
2014-06-07 06:16:56 +08:00
|
|
|
if (!Name.empty())
|
2015-04-14 11:01:27 +08:00
|
|
|
addString(NDie, dwarf::DW_AT_name, NS->getName());
|
2014-06-07 06:16:56 +08:00
|
|
|
else
|
|
|
|
Name = "(anonymous namespace)";
|
|
|
|
DD->addAccelNamespace(Name, NDie);
|
2015-04-14 11:01:27 +08:00
|
|
|
addGlobalName(Name, NDie, NS->getScope());
|
2016-11-04 03:42:02 +08:00
|
|
|
if (NS->getExportSymbols())
|
|
|
|
addFlag(NDie, dwarf::DW_AT_export_symbols);
|
2014-04-26 02:26:14 +08:00
|
|
|
return &NDie;
|
2011-05-07 00:57:54 +08:00
|
|
|
}
|
|
|
|
|
2015-06-30 10:13:04 +08:00
|
|
|
DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
|
|
|
|
// Construct the context before querying for the existence of the DIE in case
|
|
|
|
// such construction creates the DIE.
|
|
|
|
DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
|
|
|
|
|
|
|
|
if (DIE *MDie = getDIE(M))
|
|
|
|
return MDie;
|
|
|
|
DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
|
|
|
|
|
|
|
|
if (!M->getName().empty()) {
|
|
|
|
addString(MDie, dwarf::DW_AT_name, M->getName());
|
|
|
|
addGlobalName(M->getName(), MDie, M->getScope());
|
|
|
|
}
|
|
|
|
if (!M->getConfigurationMacros().empty())
|
|
|
|
addString(MDie, dwarf::DW_AT_LLVM_config_macros,
|
|
|
|
M->getConfigurationMacros());
|
|
|
|
if (!M->getIncludePath().empty())
|
|
|
|
addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
|
|
|
|
if (!M->getISysRoot().empty())
|
|
|
|
addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
|
|
|
|
|
|
|
|
return &MDie;
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
|
2013-10-04 09:39:59 +08:00
|
|
|
// Construct the context before querying for the existence of the DIE in case
|
|
|
|
// such construction creates the DIE (as is the case for member function
|
|
|
|
// declarations).
|
Provide gmlt-like inline scope information in the skeleton CU to facilitate symbolication without needing the .dwo files
Clang -gsplit-dwarf self-host -O0, binary increases by 0.0005%, -O2,
binary increases by 25%.
A large binary inside Google, split-dwarf, -O0, and other internal flags
(GDB index, etc) increases by 1.8%, optimized build is 35%.
The size impact may be somewhat greater in .o files (I haven't measured
that much - since the linked executable -O0 numbers seemed low enough)
due to relocations. These relocations could be removed if we taught the
llvm-symbolizer to handle indexed addressing in the .o file (GDB can't
cope with this just yet, but GDB won't be reading this info anyway).
Also debug_ranges could be shared between .o and .dwo, though ideally
debug_ranges would get a schema that could used index(+offset)
addressing, and move to the .dwo file, then we'd be back to sharing
addresses in the address pool again.
But for now, these sizes seem small enough to go ahead with this.
Verified that no other DW_TAGs are produced into the .o file other than
subprograms and inlined_subroutines.
llvm-svn: 221306
2014-11-05 06:12:25 +08:00
|
|
|
DIE *ContextDIE =
|
2015-04-14 11:40:37 +08:00
|
|
|
Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
|
2014-03-19 01:41:15 +08:00
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
if (DIE *SPDie = getDIE(SP))
|
2011-08-16 01:24:54 +08:00
|
|
|
return SPDie;
|
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
if (auto *SPDecl = SP->getDeclaration()) {
|
Provide gmlt-like inline scope information in the skeleton CU to facilitate symbolication without needing the .dwo files
Clang -gsplit-dwarf self-host -O0, binary increases by 0.0005%, -O2,
binary increases by 25%.
A large binary inside Google, split-dwarf, -O0, and other internal flags
(GDB index, etc) increases by 1.8%, optimized build is 35%.
The size impact may be somewhat greater in .o files (I haven't measured
that much - since the linked executable -O0 numbers seemed low enough)
due to relocations. These relocations could be removed if we taught the
llvm-symbolizer to handle indexed addressing in the .o file (GDB can't
cope with this just yet, but GDB won't be reading this info anyway).
Also debug_ranges could be shared between .o and .dwo, though ideally
debug_ranges would get a schema that could used index(+offset)
addressing, and move to the .dwo file, then we'd be back to sharing
addresses in the address pool again.
But for now, these sizes seem small enough to go ahead with this.
Verified that no other DW_TAGs are produced into the .o file other than
subprograms and inlined_subroutines.
llvm-svn: 221306
2014-11-05 06:12:25 +08:00
|
|
|
if (!Minimal) {
|
|
|
|
// Add subprogram definitions to the CU die directly.
|
|
|
|
ContextDIE = &getUnitDie();
|
|
|
|
// Build the decl now to ensure it precedes the definition.
|
|
|
|
getOrCreateSubprogramDIE(SPDecl);
|
|
|
|
}
|
2014-05-22 02:04:33 +08:00
|
|
|
}
|
2012-05-28 02:36:44 +08:00
|
|
|
|
|
|
|
// DW_TAG_inlined_subroutine may refer to this DIE.
|
2014-04-26 02:52:29 +08:00
|
|
|
DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
|
2012-05-28 02:36:44 +08:00
|
|
|
|
2014-06-05 08:25:26 +08:00
|
|
|
// Stop here and fill this in later, depending on whether or not this
|
DebugInfo: Lazily attach definition attributes to definitions.
This is a precursor to fixing inlined debug info where the concrete,
out-of-line definition may preceed any inlined usage. To cope with this,
the attributes that may appear on the concrete definition or the
abstract definition are delayed until the end of the module. Then, if an
abstract definition was created, it is referenced (and no other
attributes are added to the out-of-line definition), otherwise the
attributes are added directly to the out-of-line definition.
In a couple of cases this causes not just reordering of attributes, but
reordering of types. When the creation of the attribute is delayed, if
that creation would create a type (such as for a DW_AT_type attribute)
then other top level DIEs may've been constructed during the delay,
causing the referenced type to be created and added after those
intervening DIEs. In the extreme case, in cross-cu-inlining.ll, this
actually causes the DW_TAG_basic_type for "int" to move from one CU to
another.
llvm-svn: 209674
2014-05-28 02:37:43 +08:00
|
|
|
// subprogram turns out to have inlined instances or not.
|
2015-04-14 11:40:37 +08:00
|
|
|
if (SP->isDefinition())
|
DebugInfo: Lazily attach definition attributes to definitions.
This is a precursor to fixing inlined debug info where the concrete,
out-of-line definition may preceed any inlined usage. To cope with this,
the attributes that may appear on the concrete definition or the
abstract definition are delayed until the end of the module. Then, if an
abstract definition was created, it is referenced (and no other
attributes are added to the out-of-line definition), otherwise the
attributes are added directly to the out-of-line definition.
In a couple of cases this causes not just reordering of attributes, but
reordering of types. When the creation of the attribute is delayed, if
that creation would create a type (such as for a DW_AT_type attribute)
then other top level DIEs may've been constructed during the delay,
causing the referenced type to be created and added after those
intervening DIEs. In the extreme case, in cross-cu-inlining.ll, this
actually causes the DW_TAG_basic_type for "int" to move from one CU to
another.
llvm-svn: 209674
2014-05-28 02:37:43 +08:00
|
|
|
return &SPDie;
|
|
|
|
|
2014-05-28 02:37:38 +08:00
|
|
|
applySubprogramAttributes(SP, SPDie);
|
|
|
|
return &SPDie;
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
|
Provide gmlt-like inline scope information in the skeleton CU to facilitate symbolication without needing the .dwo files
Clang -gsplit-dwarf self-host -O0, binary increases by 0.0005%, -O2,
binary increases by 25%.
A large binary inside Google, split-dwarf, -O0, and other internal flags
(GDB index, etc) increases by 1.8%, optimized build is 35%.
The size impact may be somewhat greater in .o files (I haven't measured
that much - since the linked executable -O0 numbers seemed low enough)
due to relocations. These relocations could be removed if we taught the
llvm-symbolizer to handle indexed addressing in the .o file (GDB can't
cope with this just yet, but GDB won't be reading this info anyway).
Also debug_ranges could be shared between .o and .dwo, though ideally
debug_ranges would get a schema that could used index(+offset)
addressing, and move to the .dwo file, then we'd be back to sharing
addresses in the address pool again.
But for now, these sizes seem small enough to go ahead with this.
Verified that no other DW_TAGs are produced into the .o file other than
subprograms and inlined_subroutines.
llvm-svn: 221306
2014-11-05 06:12:25 +08:00
|
|
|
DIE &SPDie) {
|
2014-05-28 02:37:38 +08:00
|
|
|
DIE *DeclDie = nullptr;
|
|
|
|
StringRef DeclLinkageName;
|
2015-04-14 11:40:37 +08:00
|
|
|
if (auto *SPDecl = SP->getDeclaration()) {
|
DebugInfo: Lazily attach definition attributes to definitions.
This is a precursor to fixing inlined debug info where the concrete,
out-of-line definition may preceed any inlined usage. To cope with this,
the attributes that may appear on the concrete definition or the
abstract definition are delayed until the end of the module. Then, if an
abstract definition was created, it is referenced (and no other
attributes are added to the out-of-line definition), otherwise the
attributes are added directly to the out-of-line definition.
In a couple of cases this causes not just reordering of attributes, but
reordering of types. When the creation of the attribute is delayed, if
that creation would create a type (such as for a DW_AT_type attribute)
then other top level DIEs may've been constructed during the delay,
causing the referenced type to be created and added after those
intervening DIEs. In the extreme case, in cross-cu-inlining.ll, this
actually causes the DW_TAG_basic_type for "int" to move from one CU to
another.
llvm-svn: 209674
2014-05-28 02:37:43 +08:00
|
|
|
DeclDie = getDIE(SPDecl);
|
2014-06-05 08:25:26 +08:00
|
|
|
assert(DeclDie && "This DIE should've already been constructed when the "
|
2014-06-08 05:23:09 +08:00
|
|
|
"definition DIE was created in "
|
2014-06-05 08:25:26 +08:00
|
|
|
"getOrCreateSubprogramDIE");
|
2016-12-02 09:55:17 +08:00
|
|
|
// Look at the Decl's linkage name only if we emitted it.
|
|
|
|
if (DD->useAllLinkageNames())
|
|
|
|
DeclLinkageName = SPDecl->getLinkageName();
|
2015-10-07 08:04:16 +08:00
|
|
|
unsigned DeclID =
|
|
|
|
getOrCreateSourceID(SPDecl->getFilename(), SPDecl->getDirectory());
|
|
|
|
unsigned DefID = getOrCreateSourceID(SP->getFilename(), SP->getDirectory());
|
|
|
|
if (DeclID != DefID)
|
|
|
|
addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
|
|
|
|
|
|
|
|
if (SP->getLine() != SPDecl->getLine())
|
|
|
|
addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
|
2014-05-28 02:37:38 +08:00
|
|
|
}
|
2011-11-11 06:34:29 +08:00
|
|
|
|
2011-08-16 01:24:54 +08:00
|
|
|
// Add function template parameters.
|
2015-04-14 11:40:37 +08:00
|
|
|
addTemplateParams(SPDie, SP->getTemplateParams());
|
2011-08-16 01:24:54 +08:00
|
|
|
|
2014-04-15 05:16:04 +08:00
|
|
|
// Add the linkage name if we have one and it isn't in the Decl.
|
2015-04-14 11:40:37 +08:00
|
|
|
StringRef LinkageName = SP->getLinkageName();
|
2014-05-22 02:04:33 +08:00
|
|
|
assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
|
|
|
|
LinkageName == DeclLinkageName) &&
|
|
|
|
"decl has a linkage name and it is different");
|
2016-04-19 06:41:41 +08:00
|
|
|
if (DeclLinkageName.empty() &&
|
|
|
|
// Always emit it for abstract subprograms.
|
|
|
|
(DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
|
2015-03-11 06:44:45 +08:00
|
|
|
addLinkageName(SPDie, LinkageName);
|
2014-05-22 02:04:33 +08:00
|
|
|
|
Provide gmlt-like inline scope information in the skeleton CU to facilitate symbolication without needing the .dwo files
Clang -gsplit-dwarf self-host -O0, binary increases by 0.0005%, -O2,
binary increases by 25%.
A large binary inside Google, split-dwarf, -O0, and other internal flags
(GDB index, etc) increases by 1.8%, optimized build is 35%.
The size impact may be somewhat greater in .o files (I haven't measured
that much - since the linked executable -O0 numbers seemed low enough)
due to relocations. These relocations could be removed if we taught the
llvm-symbolizer to handle indexed addressing in the .o file (GDB can't
cope with this just yet, but GDB won't be reading this info anyway).
Also debug_ranges could be shared between .o and .dwo, though ideally
debug_ranges would get a schema that could used index(+offset)
addressing, and move to the .dwo file, then we'd be back to sharing
addresses in the address pool again.
But for now, these sizes seem small enough to go ahead with this.
Verified that no other DW_TAGs are produced into the .o file other than
subprograms and inlined_subroutines.
llvm-svn: 221306
2014-11-05 06:12:25 +08:00
|
|
|
if (!DeclDie)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Refer to the function declaration where all the other attributes will be
|
|
|
|
// found.
|
|
|
|
addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
|
2017-01-19 08:44:11 +08:00
|
|
|
bool SkipSPAttributes) {
|
|
|
|
// If -fdebug-info-for-profiling is enabled, need to emit the subprogram
|
|
|
|
// and its source location.
|
|
|
|
bool SkipSPSourceLocation = SkipSPAttributes &&
|
Change debug-info-for-profiling from a TargetOption to a function attribute.
Summary: LTO requires the debug-info-for-profiling to be a function attribute.
Reviewers: echristo, mehdi_amini, dblaikie, probinson, aprantl
Reviewed By: mehdi_amini, dblaikie, aprantl
Subscribers: aprantl, probinson, ahatanak, llvm-commits, mehdi_amini
Differential Revision: https://reviews.llvm.org/D29203
llvm-svn: 293833
2017-02-02 06:45:09 +08:00
|
|
|
!CUNode->getDebugInfoForProfiling();
|
2017-01-19 08:44:11 +08:00
|
|
|
if (!SkipSPSourceLocation)
|
Provide gmlt-like inline scope information in the skeleton CU to facilitate symbolication without needing the .dwo files
Clang -gsplit-dwarf self-host -O0, binary increases by 0.0005%, -O2,
binary increases by 25%.
A large binary inside Google, split-dwarf, -O0, and other internal flags
(GDB index, etc) increases by 1.8%, optimized build is 35%.
The size impact may be somewhat greater in .o files (I haven't measured
that much - since the linked executable -O0 numbers seemed low enough)
due to relocations. These relocations could be removed if we taught the
llvm-symbolizer to handle indexed addressing in the .o file (GDB can't
cope with this just yet, but GDB won't be reading this info anyway).
Also debug_ranges could be shared between .o and .dwo, though ideally
debug_ranges would get a schema that could used index(+offset)
addressing, and move to the .dwo file, then we'd be back to sharing
addresses in the address pool again.
But for now, these sizes seem small enough to go ahead with this.
Verified that no other DW_TAGs are produced into the .o file other than
subprograms and inlined_subroutines.
llvm-svn: 221306
2014-11-05 06:12:25 +08:00
|
|
|
if (applySubprogramDefinitionAttributes(SP, SPDie))
|
|
|
|
return;
|
2012-08-24 06:52:55 +08:00
|
|
|
|
2011-08-16 01:24:54 +08:00
|
|
|
// Constructors and operators for anonymous aggregates do not have names.
|
2015-04-14 11:40:37 +08:00
|
|
|
if (!SP->getName().empty())
|
|
|
|
addString(SPDie, dwarf::DW_AT_name, SP->getName());
|
2011-08-16 01:24:54 +08:00
|
|
|
|
2017-01-19 08:44:11 +08:00
|
|
|
if (!SkipSPSourceLocation)
|
|
|
|
addSourceLine(SPDie, SP);
|
|
|
|
|
2014-09-19 12:47:46 +08:00
|
|
|
// Skip the rest of the attributes under -gmlt to save space.
|
2017-01-19 08:44:11 +08:00
|
|
|
if (SkipSPAttributes)
|
2014-09-19 12:30:36 +08:00
|
|
|
return;
|
|
|
|
|
2012-02-22 16:46:21 +08:00
|
|
|
// Add the prototype if we have a prototype and we have a C like
|
|
|
|
// language.
|
2013-11-16 07:50:53 +08:00
|
|
|
uint16_t Language = getLanguage();
|
2015-04-14 11:40:37 +08:00
|
|
|
if (SP->isPrototyped() &&
|
2013-10-19 09:04:47 +08:00
|
|
|
(Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
|
2012-02-22 16:46:21 +08:00
|
|
|
Language == dwarf::DW_LANG_ObjC))
|
2012-08-24 09:14:27 +08:00
|
|
|
addFlag(SPDie, dwarf::DW_AT_prototyped);
|
2011-08-16 01:24:54 +08:00
|
|
|
|
2016-06-09 04:34:29 +08:00
|
|
|
unsigned CC = 0;
|
2015-08-29 05:38:24 +08:00
|
|
|
DITypeRefArray Args;
|
2016-06-09 04:34:29 +08:00
|
|
|
if (const DISubroutineType *SPTy = SP->getType()) {
|
2015-08-29 05:38:24 +08:00
|
|
|
Args = SPTy->getTypeArray();
|
2016-06-09 04:34:29 +08:00
|
|
|
CC = SPTy->getCC();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a DW_AT_calling_convention if this has an explicit convention.
|
|
|
|
if (CC && CC != dwarf::DW_CC_normal)
|
|
|
|
addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
|
2011-08-16 01:24:54 +08:00
|
|
|
|
2013-10-22 01:48:51 +08:00
|
|
|
// Add a return type. If this is a type like a C/C++ void type we don't add a
|
|
|
|
// return type.
|
2015-04-07 12:14:33 +08:00
|
|
|
if (Args.size())
|
2015-04-08 02:07:41 +08:00
|
|
|
if (auto Ty = resolve(Args[0]))
|
2015-04-07 12:14:33 +08:00
|
|
|
addType(SPDie, Ty);
|
2011-08-16 01:24:54 +08:00
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
unsigned VK = SP->getVirtuality();
|
2011-08-16 01:24:54 +08:00
|
|
|
if (VK) {
|
2011-12-14 08:56:07 +08:00
|
|
|
addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
|
2016-03-18 07:58:03 +08:00
|
|
|
if (SP->getVirtualIndex() != -1u) {
|
|
|
|
DIELoc *Block = getDIELoc();
|
|
|
|
addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
|
|
|
|
addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
|
|
|
|
addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
|
|
|
|
}
|
2013-11-12 02:52:36 +08:00
|
|
|
ContainingTypeMap.insert(
|
2015-04-14 11:40:37 +08:00
|
|
|
std::make_pair(&SPDie, resolve(SP->getContainingType())));
|
2011-08-16 01:24:54 +08:00
|
|
|
}
|
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
if (!SP->isDefinition()) {
|
2012-08-24 09:14:27 +08:00
|
|
|
addFlag(SPDie, dwarf::DW_AT_declaration);
|
2012-11-21 08:34:38 +08:00
|
|
|
|
2011-08-16 01:24:54 +08:00
|
|
|
// Add arguments. Do not add arguments for subprogram definition. They will
|
|
|
|
// be handled while processing variables.
|
2014-05-01 06:58:19 +08:00
|
|
|
constructSubprogramArguments(SPDie, Args);
|
2011-08-16 01:24:54 +08:00
|
|
|
}
|
|
|
|
|
2017-04-27 06:56:44 +08:00
|
|
|
addThrownTypes(SPDie, SP->getThrownTypes());
|
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
if (SP->isArtificial())
|
2012-08-24 09:14:27 +08:00
|
|
|
addFlag(SPDie, dwarf::DW_AT_artificial);
|
2011-08-16 01:24:54 +08:00
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
if (!SP->isLocalToUnit())
|
2012-08-24 09:14:27 +08:00
|
|
|
addFlag(SPDie, dwarf::DW_AT_external);
|
2011-08-16 01:24:54 +08:00
|
|
|
|
2016-05-25 05:19:28 +08:00
|
|
|
if (DD->useAppleExtensionAttributes()) {
|
|
|
|
if (SP->isOptimized())
|
|
|
|
addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
|
2011-08-16 01:24:54 +08:00
|
|
|
|
2016-05-25 05:19:28 +08:00
|
|
|
if (unsigned isa = Asm->getISAEncoding())
|
|
|
|
addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
|
|
|
|
}
|
2011-08-16 01:24:54 +08:00
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
if (SP->isLValueReference())
|
2013-12-19 05:48:19 +08:00
|
|
|
addFlag(SPDie, dwarf::DW_AT_reference);
|
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
if (SP->isRValueReference())
|
2013-12-19 05:48:19 +08:00
|
|
|
addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
|
|
|
|
|
2016-08-18 00:02:43 +08:00
|
|
|
if (SP->isNoReturn())
|
|
|
|
addFlag(SPDie, dwarf::DW_AT_noreturn);
|
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
if (SP->isProtected())
|
2014-01-18 10:12:00 +08:00
|
|
|
addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
|
|
|
|
dwarf::DW_ACCESS_protected);
|
2015-04-14 11:40:37 +08:00
|
|
|
else if (SP->isPrivate())
|
2014-01-18 10:12:00 +08:00
|
|
|
addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
|
|
|
|
dwarf::DW_ACCESS_private);
|
2015-04-14 11:40:37 +08:00
|
|
|
else if (SP->isPublic())
|
2014-01-18 10:12:00 +08:00
|
|
|
addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
|
|
|
|
dwarf::DW_ACCESS_public);
|
|
|
|
|
2015-04-14 11:40:37 +08:00
|
|
|
if (SP->isExplicit())
|
2014-01-18 10:12:00 +08:00
|
|
|
addFlag(SPDie, dwarf::DW_AT_explicit);
|
2016-11-29 05:32:19 +08:00
|
|
|
|
|
|
|
if (SP->isMainSubprogram())
|
|
|
|
addFlag(SPDie, dwarf::DW_AT_main_subprogram);
|
2011-08-16 01:24:54 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
|
2015-04-22 02:44:06 +08:00
|
|
|
DIE *IndexTy) {
|
2014-04-26 02:52:29 +08:00
|
|
|
DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
|
2014-04-26 03:33:43 +08:00
|
|
|
addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
|
2012-12-05 05:34:03 +08:00
|
|
|
|
2012-12-06 15:38:10 +08:00
|
|
|
// The LowerBound value defines the lower bounds which is typically zero for
|
|
|
|
// C/C++. The Count value is the number of elements. Values are 64 bit. If
|
|
|
|
// Count == -1 then the array is unbounded and we do not emit
|
2014-10-01 08:56:55 +08:00
|
|
|
// DW_AT_lower_bound and DW_AT_count attributes.
|
2015-04-16 09:37:00 +08:00
|
|
|
int64_t LowerBound = SR->getLowerBound();
|
2012-12-06 15:55:19 +08:00
|
|
|
int64_t DefaultLowerBound = getDefaultLowerBound();
|
2015-04-16 09:37:00 +08:00
|
|
|
int64_t Count = SR->getCount();
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2012-12-06 15:55:19 +08:00
|
|
|
if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
|
2013-10-22 01:28:37 +08:00
|
|
|
addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
|
2012-12-06 15:38:10 +08:00
|
|
|
|
2014-10-01 08:56:55 +08:00
|
|
|
if (Count != -1)
|
2012-12-05 05:34:03 +08:00
|
|
|
// FIXME: An unbounded array should reference the expression that defines
|
|
|
|
// the array.
|
2014-10-01 08:56:55 +08:00
|
|
|
addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2014-11-02 11:09:13 +08:00
|
|
|
DIE *DwarfUnit::getIndexTyDie() {
|
|
|
|
if (IndexTyDie)
|
|
|
|
return IndexTyDie;
|
|
|
|
// Construct an integer type to use for indexes.
|
2016-12-02 02:56:29 +08:00
|
|
|
IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
|
2014-11-02 11:09:13 +08:00
|
|
|
addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
|
|
|
|
addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
|
|
|
|
addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
|
|
|
|
dwarf::DW_ATE_unsigned);
|
|
|
|
return IndexTyDie;
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
|
2015-04-16 09:01:28 +08:00
|
|
|
if (CTy->isVector())
|
2014-04-26 02:26:14 +08:00
|
|
|
addFlag(Buffer, dwarf::DW_AT_GNU_vector);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2013-08-08 15:40:37 +08:00
|
|
|
// Emit the element type.
|
2015-04-16 09:01:28 +08:00
|
|
|
addType(Buffer, resolve(CTy->getBaseType()));
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// Get an anonymous type for index type.
|
2013-01-05 05:51:53 +08:00
|
|
|
// FIXME: This type should be passed down from the front end
|
|
|
|
// as different languages may have different sizes for indexes.
|
2011-04-13 07:21:44 +08:00
|
|
|
DIE *IdxTy = getIndexTyDie();
|
|
|
|
|
|
|
|
// Add subranges to array type.
|
2015-04-30 00:38:44 +08:00
|
|
|
DINodeArray Elements = CTy->getElements();
|
2015-04-07 12:14:33 +08:00
|
|
|
for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
|
2015-04-16 09:53:33 +08:00
|
|
|
// FIXME: Should this really be such a loose cast?
|
2015-04-30 00:38:44 +08:00
|
|
|
if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
|
2015-04-16 09:53:33 +08:00
|
|
|
if (Element->getTag() == dwarf::DW_TAG_subrange_type)
|
2015-04-30 00:38:44 +08:00
|
|
|
constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
|
|
|
|
DINodeArray Elements = CTy->getElements();
|
2013-11-12 02:52:39 +08:00
|
|
|
|
|
|
|
// Add enumerators to enumeration type.
|
2015-04-07 12:14:33 +08:00
|
|
|
for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
|
2015-04-07 07:27:40 +08:00
|
|
|
if (Enum) {
|
2014-04-26 02:52:29 +08:00
|
|
|
DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
|
2015-04-16 09:37:00 +08:00
|
|
|
StringRef Name = Enum->getName();
|
2013-11-12 02:52:39 +08:00
|
|
|
addString(Enumerator, dwarf::DW_AT_name, Name);
|
2015-04-16 09:37:00 +08:00
|
|
|
int64_t Value = Enum->getValue();
|
2013-11-19 17:28:34 +08:00
|
|
|
addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
|
|
|
|
Value);
|
2013-11-12 02:52:39 +08:00
|
|
|
}
|
|
|
|
}
|
2015-04-30 00:38:44 +08:00
|
|
|
const DIType *DTy = resolve(CTy->getBaseType());
|
2013-11-12 02:52:39 +08:00
|
|
|
if (DTy) {
|
2014-04-26 02:26:14 +08:00
|
|
|
addType(Buffer, DTy);
|
|
|
|
addFlag(Buffer, dwarf::DW_AT_enum_class);
|
2013-11-12 02:52:39 +08:00
|
|
|
}
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
|
|
|
|
2013-12-10 07:32:48 +08:00
|
|
|
void DwarfUnit::constructContainingTypeDIEs() {
|
2015-04-18 08:35:36 +08:00
|
|
|
for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
|
2013-10-19 09:04:47 +08:00
|
|
|
CI != CE; ++CI) {
|
2014-04-26 02:26:14 +08:00
|
|
|
DIE &SPDie = *CI->first;
|
2015-04-30 00:38:44 +08:00
|
|
|
const DINode *D = CI->second;
|
2013-11-16 07:09:13 +08:00
|
|
|
if (!D)
|
2013-10-19 09:04:47 +08:00
|
|
|
continue;
|
2013-11-16 07:09:13 +08:00
|
|
|
DIE *NDie = getDIE(D);
|
2013-10-19 09:04:47 +08:00
|
|
|
if (!NDie)
|
|
|
|
continue;
|
2014-04-26 03:33:43 +08:00
|
|
|
addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
|
2011-08-16 01:24:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
|
2015-04-16 07:49:09 +08:00
|
|
|
DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
|
|
|
|
StringRef Name = DT->getName();
|
2011-04-13 07:21:44 +08:00
|
|
|
if (!Name.empty())
|
2011-10-27 14:44:11 +08:00
|
|
|
addString(MemberDie, dwarf::DW_AT_name, Name);
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2015-04-16 07:49:09 +08:00
|
|
|
addType(MemberDie, resolve(DT->getBaseType()));
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
addSourceLine(MemberDie, DT);
|
|
|
|
|
2015-04-16 07:49:09 +08:00
|
|
|
if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
|
2011-04-13 07:21:44 +08:00
|
|
|
|
|
|
|
// For C++, virtual base classes are not at fixed offset. Use following
|
|
|
|
// expression to extract appropriate offset from vtable.
|
|
|
|
// BaseAddr = ObAddr + *((*ObAddr) - Offset)
|
|
|
|
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
|
|
|
|
addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
|
|
|
|
addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
|
2015-04-16 07:49:09 +08:00
|
|
|
addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
|
|
|
|
addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
|
|
|
|
addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
|
2013-10-22 01:28:37 +08:00
|
|
|
|
|
|
|
addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
|
2013-11-01 08:25:45 +08:00
|
|
|
} else {
|
2015-04-16 07:49:09 +08:00
|
|
|
uint64_t Size = DT->getSizeInBits();
|
2016-07-12 20:06:34 +08:00
|
|
|
uint64_t FieldSize = DD->getBaseTypeSize(DT);
|
2016-10-27 05:32:29 +08:00
|
|
|
uint32_t AlignInBytes = DT->getAlignInBytes();
|
2013-11-01 08:25:45 +08:00
|
|
|
uint64_t OffsetInBytes;
|
2016-05-18 04:12:08 +08:00
|
|
|
|
2016-05-17 10:37:53 +08:00
|
|
|
bool IsBitfield = FieldSize && Size != FieldSize;
|
|
|
|
if (IsBitfield) {
|
2014-03-13 01:14:46 +08:00
|
|
|
// Handle bitfield, assume bytes are 8 bits.
|
2016-05-18 05:07:16 +08:00
|
|
|
if (DD->useDWARF2Bitfields())
|
2016-05-17 06:45:10 +08:00
|
|
|
addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
|
2014-03-13 01:14:46 +08:00
|
|
|
addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
|
2016-04-28 23:37:48 +08:00
|
|
|
|
2015-04-16 07:49:09 +08:00
|
|
|
uint64_t Offset = DT->getOffsetInBits();
|
2016-10-20 08:13:12 +08:00
|
|
|
// We can't use DT->getAlignInBits() here: AlignInBits for member type
|
|
|
|
// is non-zero if and only if alignment was forced (e.g. _Alignas()),
|
|
|
|
// which can't be done with bitfields. Thus we use FieldSize here.
|
|
|
|
uint32_t AlignInBits = FieldSize;
|
|
|
|
uint32_t AlignMask = ~(AlignInBits - 1);
|
2015-06-27 07:31:27 +08:00
|
|
|
// The bits from the start of the storage unit to the start of the field.
|
|
|
|
uint64_t StartBitOffset = Offset - (Offset & AlignMask);
|
2015-06-28 05:55:00 +08:00
|
|
|
// The byte offset of the field's aligned storage unit inside the struct.
|
|
|
|
OffsetInBytes = (Offset - StartBitOffset) / 8;
|
2016-04-28 23:37:48 +08:00
|
|
|
|
2016-05-18 05:07:16 +08:00
|
|
|
if (DD->useDWARF2Bitfields()) {
|
2016-04-28 23:37:52 +08:00
|
|
|
uint64_t HiMark = (Offset + FieldSize) & AlignMask;
|
|
|
|
uint64_t FieldOffset = (HiMark - FieldSize);
|
|
|
|
Offset -= FieldOffset;
|
|
|
|
|
|
|
|
// Maybe we need to work from the other end.
|
|
|
|
if (Asm->getDataLayout().isLittleEndian())
|
|
|
|
Offset = FieldSize - (Offset + Size);
|
|
|
|
|
|
|
|
addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
|
|
|
|
OffsetInBytes = FieldOffset >> 3;
|
2016-05-18 04:12:08 +08:00
|
|
|
} else {
|
|
|
|
addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
|
2016-04-28 23:37:48 +08:00
|
|
|
}
|
2016-05-18 04:12:08 +08:00
|
|
|
} else {
|
2013-11-01 08:25:45 +08:00
|
|
|
// This is not a bitfield.
|
2015-06-27 07:31:27 +08:00
|
|
|
OffsetInBytes = DT->getOffsetInBits() / 8;
|
2016-10-26 19:59:03 +08:00
|
|
|
if (AlignInBytes)
|
|
|
|
addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
|
|
|
|
AlignInBytes);
|
2016-05-18 04:12:08 +08:00
|
|
|
}
|
2014-01-03 08:48:38 +08:00
|
|
|
|
2014-01-03 09:30:05 +08:00
|
|
|
if (DD->getDwarfVersion() <= 2) {
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
|
2014-04-26 02:26:14 +08:00
|
|
|
addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
|
|
|
|
addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
|
2014-01-03 09:30:05 +08:00
|
|
|
addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
|
2016-05-18 05:07:16 +08:00
|
|
|
} else if (!IsBitfield || DD->useDWARF2Bitfields())
|
2014-01-03 09:30:05 +08:00
|
|
|
addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
|
|
|
|
OffsetInBytes);
|
2013-11-01 08:25:45 +08:00
|
|
|
}
|
2011-04-13 07:21:44 +08:00
|
|
|
|
2015-04-16 07:49:09 +08:00
|
|
|
if (DT->isProtected())
|
2011-12-13 13:09:11 +08:00
|
|
|
addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
|
2011-04-13 07:21:44 +08:00
|
|
|
dwarf::DW_ACCESS_protected);
|
2015-04-16 07:49:09 +08:00
|
|
|
else if (DT->isPrivate())
|
2011-12-13 13:09:11 +08:00
|
|
|
addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
|
2011-04-13 07:21:44 +08:00
|
|
|
dwarf::DW_ACCESS_private);
|
|
|
|
// Otherwise C++ member and base classes are considered public.
|
2015-04-16 07:49:09 +08:00
|
|
|
else if (DT->isPublic())
|
2011-12-13 13:09:11 +08:00
|
|
|
addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
|
2011-04-13 07:21:44 +08:00
|
|
|
dwarf::DW_ACCESS_public);
|
2015-04-16 07:49:09 +08:00
|
|
|
if (DT->isVirtual())
|
2011-12-14 08:56:07 +08:00
|
|
|
addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
|
2011-04-13 07:21:44 +08:00
|
|
|
dwarf::DW_VIRTUALITY_virtual);
|
2011-04-16 08:11:51 +08:00
|
|
|
|
|
|
|
// Objective-C properties.
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:
- MSVC can only handle `sizeof()` on types, not values. Change the
assert.
- GCC doesn't know the `is_trivially_copyable` type trait. Instead of
asserting it, add destructors.
- Call placement new even when constructing POD (i.e., the pointers).
- Instead of copying the char buffer, copy the casted classes.
I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle. If the bots disagree with me, I'll remove them.
- Check that the constructed type is either standard layout or a
pointer. This protects against a programming error: we really want
the "small" `DIEValue`s to be small and simple, so don't
accidentally change them not to be.
- Similarly, check that the size of the buffer is no bigger than a
`uint64_t` or a pointer. (I thought checking against
`sizeof(uint64_t)` would be good enough, but Chandler suggested that
pointers might sometimes be bigger than that in the context of
sanitizers.)
I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie). Without that, this commit would
be almost unintelligible.
Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference. It's now a discriminated union, with a `Val` field storing
the actual type. The classes that used to inherit from `DIEValue` no
longer do. There are two categories of these:
- Small values fit in a single pointer and are stored by value.
- Large values require auxiliary storage, and are stored by reference.
The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp. It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.
This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit. I
measured an increase from 845 MB to 879 MB, around 3.9%. The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental. (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)
(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
if (DINode *PNode = DT->getObjCProperty())
|
|
|
|
if (DIE *PDie = getDIE(PNode))
|
2015-06-26 07:46:41 +08:00
|
|
|
MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
|
|
|
|
dwarf::DW_FORM_ref4, DIEEntry(*PDie));
|
2012-02-07 01:49:43 +08:00
|
|
|
|
2015-04-16 07:49:09 +08:00
|
|
|
if (DT->isArtificial())
|
2012-12-14 06:43:07 +08:00
|
|
|
addFlag(MemberDie, dwarf::DW_AT_artificial);
|
2011-04-13 07:21:44 +08:00
|
|
|
}
|
2013-01-16 09:22:23 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
|
2015-04-07 03:49:39 +08:00
|
|
|
if (!DT)
|
2014-04-24 14:44:33 +08:00
|
|
|
return nullptr;
|
2013-01-16 09:22:23 +08:00
|
|
|
|
2013-10-15 04:33:57 +08:00
|
|
|
// Construct the context before querying for the existence of the DIE in case
|
|
|
|
// such construction creates the DIE.
|
2015-04-16 07:49:09 +08:00
|
|
|
DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
|
2013-11-15 05:24:34 +08:00
|
|
|
assert(dwarf::isType(ContextDIE->getTag()) &&
|
|
|
|
"Static member should belong to a type.");
|
2013-10-15 04:33:57 +08:00
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
if (DIE *StaticMemberDIE = getDIE(DT))
|
2013-10-15 04:33:57 +08:00
|
|
|
return StaticMemberDIE;
|
|
|
|
|
2015-04-16 07:49:09 +08:00
|
|
|
DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
|
2013-10-15 04:33:57 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
const DIType *Ty = resolve(DT->getBaseType());
|
2013-01-16 09:22:23 +08:00
|
|
|
|
2015-04-16 07:49:09 +08:00
|
|
|
addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
|
2013-01-16 09:22:23 +08:00
|
|
|
addType(StaticMemberDIE, Ty);
|
|
|
|
addSourceLine(StaticMemberDIE, DT);
|
|
|
|
addFlag(StaticMemberDIE, dwarf::DW_AT_external);
|
|
|
|
addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
|
|
|
|
|
|
|
|
// FIXME: We could omit private if the parent is a class_type, and
|
|
|
|
// public if the parent is something else.
|
2015-04-16 07:49:09 +08:00
|
|
|
if (DT->isProtected())
|
2013-01-16 09:22:23 +08:00
|
|
|
addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
|
|
|
|
dwarf::DW_ACCESS_protected);
|
2015-04-16 07:49:09 +08:00
|
|
|
else if (DT->isPrivate())
|
2013-01-16 09:22:23 +08:00
|
|
|
addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
|
|
|
|
dwarf::DW_ACCESS_private);
|
2015-04-16 07:49:09 +08:00
|
|
|
else if (DT->isPublic())
|
2013-01-16 09:22:23 +08:00
|
|
|
addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
|
|
|
|
dwarf::DW_ACCESS_public);
|
|
|
|
|
2015-04-16 07:49:09 +08:00
|
|
|
if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
|
2014-05-11 23:56:59 +08:00
|
|
|
addConstantValue(StaticMemberDIE, CI, Ty);
|
2015-04-16 07:49:09 +08:00
|
|
|
if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
|
2013-01-20 09:18:01 +08:00
|
|
|
addConstantFPValue(StaticMemberDIE, CFP);
|
2013-01-16 09:22:23 +08:00
|
|
|
|
2016-10-27 05:32:29 +08:00
|
|
|
if (uint32_t AlignInBytes = DT->getAlignInBytes())
|
2016-10-26 19:59:03 +08:00
|
|
|
addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
|
|
|
|
AlignInBytes);
|
|
|
|
|
2014-04-26 02:26:14 +08:00
|
|
|
return &StaticMemberDIE;
|
2013-01-16 09:22:23 +08:00
|
|
|
}
|
2013-10-31 04:42:41 +08:00
|
|
|
|
2017-03-01 04:24:55 +08:00
|
|
|
void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
|
2014-11-02 07:59:23 +08:00
|
|
|
// Emit size of content not including length itself
|
2015-04-25 03:11:51 +08:00
|
|
|
Asm->OutStreamer->AddComment("Length of Unit");
|
2016-12-02 02:56:29 +08:00
|
|
|
Asm->EmitInt32(getHeaderSize() + getUnitDie().getSize());
|
2014-11-02 07:59:23 +08:00
|
|
|
|
2015-04-25 03:11:51 +08:00
|
|
|
Asm->OutStreamer->AddComment("DWARF version number");
|
2017-03-01 04:24:55 +08:00
|
|
|
unsigned Version = DD->getDwarfVersion();
|
|
|
|
Asm->EmitInt16(Version);
|
|
|
|
|
|
|
|
// DWARF v5 reorders the address size and adds a unit type.
|
|
|
|
if (Version >= 5) {
|
|
|
|
Asm->OutStreamer->AddComment("DWARF Unit Type");
|
|
|
|
Asm->EmitInt8(UT);
|
|
|
|
Asm->OutStreamer->AddComment("Address Size (in bytes)");
|
2017-04-18 01:41:25 +08:00
|
|
|
Asm->EmitInt8(Asm->MAI->getCodePointerSize());
|
2017-03-01 04:24:55 +08:00
|
|
|
}
|
2015-03-11 00:58:10 +08:00
|
|
|
|
2013-12-05 07:39:02 +08:00
|
|
|
// We share one abbreviations table across all units so it's always at the
|
|
|
|
// start of the section. Use a relocatable offset where needed to ensure
|
|
|
|
// linking doesn't invalidate that offset.
|
2017-03-01 04:24:55 +08:00
|
|
|
Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
|
2015-03-11 00:58:10 +08:00
|
|
|
const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
|
2016-02-12 03:57:46 +08:00
|
|
|
if (UseOffsets)
|
|
|
|
Asm->EmitInt32(0);
|
|
|
|
else
|
|
|
|
Asm->emitDwarfSymbolReference(
|
|
|
|
TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
|
2015-03-11 00:58:10 +08:00
|
|
|
|
2017-03-01 04:24:55 +08:00
|
|
|
if (Version <= 4) {
|
|
|
|
Asm->OutStreamer->AddComment("Address Size (in bytes)");
|
2017-04-18 01:41:25 +08:00
|
|
|
Asm->EmitInt8(Asm->MAI->getCodePointerSize());
|
2017-03-01 04:24:55 +08:00
|
|
|
}
|
2013-10-31 04:42:41 +08:00
|
|
|
}
|
2013-12-14 05:33:40 +08:00
|
|
|
|
2015-03-11 00:58:10 +08:00
|
|
|
void DwarfTypeUnit::emitHeader(bool UseOffsets) {
|
2017-03-01 04:24:55 +08:00
|
|
|
DwarfUnit::emitCommonHeader(UseOffsets,
|
|
|
|
DD->useSplitDwarf() ? dwarf::DW_UT_split_type
|
|
|
|
: dwarf::DW_UT_type);
|
2015-04-25 03:11:51 +08:00
|
|
|
Asm->OutStreamer->AddComment("Type Signature");
|
|
|
|
Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
|
|
|
|
Asm->OutStreamer->AddComment("Type DIE Offset");
|
2014-01-10 09:38:41 +08:00
|
|
|
// In a skeleton type unit there is no type DIE so emit a zero offset.
|
2015-04-25 03:11:51 +08:00
|
|
|
Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
|
|
|
|
sizeof(Ty->getOffset()));
|
2013-12-14 05:33:40 +08:00
|
|
|
}
|
|
|
|
|
2014-11-02 16:51:37 +08:00
|
|
|
bool DwarfTypeUnit::isDwoUnit() const {
|
|
|
|
// Since there are no skeleton type units, all type units are dwo type units
|
|
|
|
// when split DWARF is being used.
|
|
|
|
return DD->useSplitDwarf();
|
|
|
|
}
|
2017-02-03 08:44:18 +08:00
|
|
|
|
|
|
|
void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die,
|
|
|
|
const DIScope *Context) {
|
|
|
|
getCU().addGlobalNameForTypeUnit(Name, Context);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
|
|
|
|
const DIScope *Context) {
|
|
|
|
getCU().addGlobalTypeUnitType(Ty, Context);
|
|
|
|
}
|
2017-04-22 15:53:44 +08:00
|
|
|
|
|
|
|
const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
|
|
|
|
if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
|
|
|
|
return nullptr;
|
|
|
|
if (isDwoUnit())
|
|
|
|
return nullptr;
|
|
|
|
return getSection()->getBeginSymbol();
|
|
|
|
}
|