2017-06-07 11:48:56 +08:00
|
|
|
//===-- llvm/BinaryFormat/Dwarf.cpp - Dwarf Framework ------------*- C++-*-===//
|
2006-02-27 20:43:29 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2006-02-27 20:43:29 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file contains support for generic dwarf information.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.h"
|
2015-02-04 05:16:49 +08:00
|
|
|
#include "llvm/ADT/StringSwitch.h"
|
2018-12-18 18:37:42 +08:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2013-09-20 06:19:37 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
|
2009-12-29 15:28:33 +08:00
|
|
|
using namespace llvm;
|
|
|
|
using namespace dwarf;
|
2006-02-27 20:43:29 +08:00
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::TagString(unsigned Tag) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Tag) {
|
2016-10-05 13:59:29 +08:00
|
|
|
default:
|
|
|
|
return StringRef();
|
2017-04-21 03:16:51 +08:00
|
|
|
#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \
|
2015-02-04 05:13:16 +08:00
|
|
|
case DW_TAG_##NAME: \
|
|
|
|
return "DW_TAG_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-04 05:16:49 +08:00
|
|
|
unsigned llvm::dwarf::getTag(StringRef TagString) {
|
|
|
|
return StringSwitch<unsigned>(TagString)
|
2017-04-21 03:16:51 +08:00
|
|
|
#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \
|
2017-06-07 11:48:56 +08:00
|
|
|
.Case("DW_TAG_" #NAME, DW_TAG_##NAME)
|
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2015-02-04 05:16:49 +08:00
|
|
|
.Default(DW_TAG_invalid);
|
|
|
|
}
|
|
|
|
|
2017-04-21 03:16:51 +08:00
|
|
|
unsigned llvm::dwarf::TagVersion(dwarf::Tag Tag) {
|
|
|
|
switch (Tag) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_TAG_##NAME: \
|
|
|
|
return VERSION;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned llvm::dwarf::TagVendor(dwarf::Tag Tag) {
|
|
|
|
switch (Tag) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_TAG_##NAME: \
|
|
|
|
return DWARF_VENDOR_##VENDOR;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::ChildrenString(unsigned Children) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Children) {
|
2017-06-07 11:48:56 +08:00
|
|
|
case DW_CHILDREN_no:
|
|
|
|
return "DW_CHILDREN_no";
|
|
|
|
case DW_CHILDREN_yes:
|
|
|
|
return "DW_CHILDREN_yes";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::AttributeString(unsigned Attribute) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Attribute) {
|
2016-10-29 02:21:39 +08:00
|
|
|
default:
|
|
|
|
return StringRef();
|
2017-04-21 03:16:51 +08:00
|
|
|
#define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_AT_##NAME: \
|
2016-10-29 02:21:39 +08:00
|
|
|
return "DW_AT_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-21 03:16:51 +08:00
|
|
|
unsigned llvm::dwarf::AttributeVersion(dwarf::Attribute Attribute) {
|
|
|
|
switch (Attribute) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_AT_##NAME: \
|
|
|
|
return VERSION;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned llvm::dwarf::AttributeVendor(dwarf::Attribute Attribute) {
|
|
|
|
switch (Attribute) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_AT_##NAME: \
|
|
|
|
return DWARF_VENDOR_##VENDOR;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::FormEncodingString(unsigned Encoding) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Encoding) {
|
2016-10-29 06:56:45 +08:00
|
|
|
default:
|
|
|
|
return StringRef();
|
2017-04-21 03:16:51 +08:00
|
|
|
#define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_FORM_##NAME: \
|
2016-10-29 06:56:45 +08:00
|
|
|
return "DW_FORM_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-21 03:16:51 +08:00
|
|
|
unsigned llvm::dwarf::FormVersion(dwarf::Form Form) {
|
|
|
|
switch (Form) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_FORM_##NAME: \
|
|
|
|
return VERSION;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned llvm::dwarf::FormVendor(dwarf::Form Form) {
|
|
|
|
switch (Form) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_FORM_##NAME: \
|
|
|
|
return DWARF_VENDOR_##VENDOR;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Encoding) {
|
2016-10-05 13:59:29 +08:00
|
|
|
default:
|
|
|
|
return StringRef();
|
2017-04-21 03:16:51 +08:00
|
|
|
#define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \
|
2015-02-13 09:04:08 +08:00
|
|
|
case DW_OP_##NAME: \
|
|
|
|
return "DW_OP_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2019-03-19 21:16:28 +08:00
|
|
|
case DW_OP_LLVM_convert:
|
|
|
|
return "DW_OP_LLVM_convert";
|
2016-12-06 02:04:47 +08:00
|
|
|
case DW_OP_LLVM_fragment:
|
|
|
|
return "DW_OP_LLVM_fragment";
|
2019-06-18 07:39:41 +08:00
|
|
|
case DW_OP_LLVM_tag_offset:
|
|
|
|
return "DW_OP_LLVM_tag_offset";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-13 09:05:00 +08:00
|
|
|
unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
|
|
|
|
return StringSwitch<unsigned>(OperationEncodingString)
|
2017-04-21 03:16:51 +08:00
|
|
|
#define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \
|
2017-06-07 11:48:56 +08:00
|
|
|
.Case("DW_OP_" #NAME, DW_OP_##NAME)
|
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2019-03-19 21:16:28 +08:00
|
|
|
.Case("DW_OP_LLVM_convert", DW_OP_LLVM_convert)
|
2016-12-06 02:04:47 +08:00
|
|
|
.Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
|
2019-06-18 07:39:41 +08:00
|
|
|
.Case("DW_OP_LLVM_tag_offset", DW_OP_LLVM_tag_offset)
|
2015-02-13 09:05:00 +08:00
|
|
|
.Default(0);
|
|
|
|
}
|
|
|
|
|
2017-04-21 03:16:51 +08:00
|
|
|
unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
|
|
|
|
switch (Op) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_OP_##NAME: \
|
|
|
|
return VERSION;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned llvm::dwarf::OperationVendor(dwarf::LocationAtom Op) {
|
|
|
|
switch (Op) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_OP_##NAME: \
|
|
|
|
return DWARF_VENDOR_##VENDOR;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::AttributeEncodingString(unsigned Encoding) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Encoding) {
|
2016-10-05 13:59:29 +08:00
|
|
|
default:
|
|
|
|
return StringRef();
|
2017-04-21 03:16:51 +08:00
|
|
|
#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
|
2015-02-07 07:45:37 +08:00
|
|
|
case DW_ATE_##NAME: \
|
|
|
|
return "DW_ATE_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-07 07:46:49 +08:00
|
|
|
unsigned llvm::dwarf::getAttributeEncoding(StringRef EncodingString) {
|
|
|
|
return StringSwitch<unsigned>(EncodingString)
|
2017-04-21 03:16:51 +08:00
|
|
|
#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
|
2017-06-07 11:48:56 +08:00
|
|
|
.Case("DW_ATE_" #NAME, DW_ATE_##NAME)
|
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2015-02-07 07:46:49 +08:00
|
|
|
.Default(0);
|
|
|
|
}
|
|
|
|
|
2017-04-21 03:16:51 +08:00
|
|
|
unsigned llvm::dwarf::AttributeEncodingVersion(dwarf::TypeKind ATE) {
|
|
|
|
switch (ATE) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_ATE_##NAME: \
|
|
|
|
return VERSION;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned llvm::dwarf::AttributeEncodingVendor(dwarf::TypeKind ATE) {
|
|
|
|
switch (ATE) {
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
|
|
|
|
case DW_ATE_##NAME: \
|
|
|
|
return DWARF_VENDOR_##VENDOR;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::DecimalSignString(unsigned Sign) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Sign) {
|
2017-06-07 11:48:56 +08:00
|
|
|
case DW_DS_unsigned:
|
|
|
|
return "DW_DS_unsigned";
|
|
|
|
case DW_DS_leading_overpunch:
|
|
|
|
return "DW_DS_leading_overpunch";
|
|
|
|
case DW_DS_trailing_overpunch:
|
|
|
|
return "DW_DS_trailing_overpunch";
|
|
|
|
case DW_DS_leading_separate:
|
|
|
|
return "DW_DS_leading_separate";
|
|
|
|
case DW_DS_trailing_separate:
|
|
|
|
return "DW_DS_trailing_separate";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::EndianityString(unsigned Endian) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Endian) {
|
2017-06-07 11:48:56 +08:00
|
|
|
case DW_END_default:
|
|
|
|
return "DW_END_default";
|
|
|
|
case DW_END_big:
|
|
|
|
return "DW_END_big";
|
|
|
|
case DW_END_little:
|
|
|
|
return "DW_END_little";
|
|
|
|
case DW_END_lo_user:
|
|
|
|
return "DW_END_lo_user";
|
|
|
|
case DW_END_hi_user:
|
|
|
|
return "DW_END_hi_user";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::AccessibilityString(unsigned Access) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Access) {
|
2009-12-30 05:09:57 +08:00
|
|
|
// Accessibility codes
|
2017-06-07 11:48:56 +08:00
|
|
|
case DW_ACCESS_public:
|
|
|
|
return "DW_ACCESS_public";
|
|
|
|
case DW_ACCESS_protected:
|
|
|
|
return "DW_ACCESS_protected";
|
|
|
|
case DW_ACCESS_private:
|
|
|
|
return "DW_ACCESS_private";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::VisibilityString(unsigned Visibility) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Visibility) {
|
2017-06-07 11:48:56 +08:00
|
|
|
case DW_VIS_local:
|
|
|
|
return "DW_VIS_local";
|
|
|
|
case DW_VIS_exported:
|
|
|
|
return "DW_VIS_exported";
|
|
|
|
case DW_VIS_qualified:
|
|
|
|
return "DW_VIS_qualified";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::VirtualityString(unsigned Virtuality) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Virtuality) {
|
2015-02-07 08:36:23 +08:00
|
|
|
default:
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2015-02-07 08:36:23 +08:00
|
|
|
#define HANDLE_DW_VIRTUALITY(ID, NAME) \
|
|
|
|
case DW_VIRTUALITY_##NAME: \
|
|
|
|
return "DW_VIRTUALITY_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-07 08:37:15 +08:00
|
|
|
unsigned llvm::dwarf::getVirtuality(StringRef VirtualityString) {
|
|
|
|
return StringSwitch<unsigned>(VirtualityString)
|
|
|
|
#define HANDLE_DW_VIRTUALITY(ID, NAME) \
|
|
|
|
.Case("DW_VIRTUALITY_" #NAME, DW_VIRTUALITY_##NAME)
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2015-02-07 08:37:15 +08:00
|
|
|
.Default(DW_VIRTUALITY_invalid);
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::LanguageString(unsigned Language) {
|
2009-05-14 07:23:20 +08:00
|
|
|
switch (Language) {
|
2015-02-07 06:53:19 +08:00
|
|
|
default:
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
llvm-dwarfdump: Improve/fix pretty printing of array dimensions
This is to address post-commit feedback from Paul Robinson on r348954.
The original commit misinterprets count and upper bound as the same thing (I thought I saw GCC producing an upper bound the same as Clang's count, but GCC correctly produces an upper bound that's one less than the count (in C, that is, where arrays are zero indexed)).
I want to preserve the C-like output for the common case, so in the absence of a lower bound the count (or one greater than the upper bound) is rendered between []. In the trickier cases, where a lower bound is specified, a half-open range is used (eg: lower bound 1, count 2 would be "[1, 3)" and an unknown parts use a '?' (eg: "[1, ?)" or "[?, 7)" or "[?, ? + 3)").
Reviewers: aprantl, probinson, JDevlieghere
Differential Revision: https://reviews.llvm.org/D55721
llvm-svn: 349670
2018-12-20 03:34:24 +08:00
|
|
|
#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
|
2015-02-07 06:53:19 +08:00
|
|
|
case DW_LANG_##NAME: \
|
|
|
|
return "DW_LANG_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-07 06:55:13 +08:00
|
|
|
unsigned llvm::dwarf::getLanguage(StringRef LanguageString) {
|
|
|
|
return StringSwitch<unsigned>(LanguageString)
|
llvm-dwarfdump: Improve/fix pretty printing of array dimensions
This is to address post-commit feedback from Paul Robinson on r348954.
The original commit misinterprets count and upper bound as the same thing (I thought I saw GCC producing an upper bound the same as Clang's count, but GCC correctly produces an upper bound that's one less than the count (in C, that is, where arrays are zero indexed)).
I want to preserve the C-like output for the common case, so in the absence of a lower bound the count (or one greater than the upper bound) is rendered between []. In the trickier cases, where a lower bound is specified, a half-open range is used (eg: lower bound 1, count 2 would be "[1, 3)" and an unknown parts use a '?' (eg: "[1, ?)" or "[?, 7)" or "[?, ? + 3)").
Reviewers: aprantl, probinson, JDevlieghere
Differential Revision: https://reviews.llvm.org/D55721
llvm-svn: 349670
2018-12-20 03:34:24 +08:00
|
|
|
#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
|
2017-04-21 03:16:51 +08:00
|
|
|
.Case("DW_LANG_" #NAME, DW_LANG_##NAME)
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2015-02-07 06:55:13 +08:00
|
|
|
.Default(0);
|
|
|
|
}
|
|
|
|
|
2017-04-21 03:16:51 +08:00
|
|
|
unsigned llvm::dwarf::LanguageVersion(dwarf::SourceLanguage Lang) {
|
|
|
|
switch (Lang) {
|
|
|
|
default:
|
|
|
|
return 0;
|
llvm-dwarfdump: Improve/fix pretty printing of array dimensions
This is to address post-commit feedback from Paul Robinson on r348954.
The original commit misinterprets count and upper bound as the same thing (I thought I saw GCC producing an upper bound the same as Clang's count, but GCC correctly produces an upper bound that's one less than the count (in C, that is, where arrays are zero indexed)).
I want to preserve the C-like output for the common case, so in the absence of a lower bound the count (or one greater than the upper bound) is rendered between []. In the trickier cases, where a lower bound is specified, a half-open range is used (eg: lower bound 1, count 2 would be "[1, 3)" and an unknown parts use a '?' (eg: "[1, ?)" or "[?, 7)" or "[?, ? + 3)").
Reviewers: aprantl, probinson, JDevlieghere
Differential Revision: https://reviews.llvm.org/D55721
llvm-svn: 349670
2018-12-20 03:34:24 +08:00
|
|
|
#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
|
2017-04-21 03:16:51 +08:00
|
|
|
case DW_LANG_##NAME: \
|
|
|
|
return VERSION;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) {
|
|
|
|
switch (Lang) {
|
|
|
|
default:
|
|
|
|
return 0;
|
llvm-dwarfdump: Improve/fix pretty printing of array dimensions
This is to address post-commit feedback from Paul Robinson on r348954.
The original commit misinterprets count and upper bound as the same thing (I thought I saw GCC producing an upper bound the same as Clang's count, but GCC correctly produces an upper bound that's one less than the count (in C, that is, where arrays are zero indexed)).
I want to preserve the C-like output for the common case, so in the absence of a lower bound the count (or one greater than the upper bound) is rendered between []. In the trickier cases, where a lower bound is specified, a half-open range is used (eg: lower bound 1, count 2 would be "[1, 3)" and an unknown parts use a '?' (eg: "[1, ?)" or "[?, 7)" or "[?, ? + 3)").
Reviewers: aprantl, probinson, JDevlieghere
Differential Revision: https://reviews.llvm.org/D55721
llvm-svn: 349670
2018-12-20 03:34:24 +08:00
|
|
|
#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
|
2017-04-21 03:16:51 +08:00
|
|
|
case DW_LANG_##NAME: \
|
|
|
|
return DWARF_VENDOR_##VENDOR;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-04-21 03:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
llvm-dwarfdump: Improve/fix pretty printing of array dimensions
This is to address post-commit feedback from Paul Robinson on r348954.
The original commit misinterprets count and upper bound as the same thing (I thought I saw GCC producing an upper bound the same as Clang's count, but GCC correctly produces an upper bound that's one less than the count (in C, that is, where arrays are zero indexed)).
I want to preserve the C-like output for the common case, so in the absence of a lower bound the count (or one greater than the upper bound) is rendered between []. In the trickier cases, where a lower bound is specified, a half-open range is used (eg: lower bound 1, count 2 would be "[1, 3)" and an unknown parts use a '?' (eg: "[1, ?)" or "[?, 7)" or "[?, ? + 3)").
Reviewers: aprantl, probinson, JDevlieghere
Differential Revision: https://reviews.llvm.org/D55721
llvm-svn: 349670
2018-12-20 03:34:24 +08:00
|
|
|
Optional<unsigned> llvm::dwarf::LanguageLowerBound(dwarf::SourceLanguage Lang) {
|
|
|
|
switch (Lang) {
|
|
|
|
default:
|
|
|
|
return None;
|
|
|
|
#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
|
|
|
|
case DW_LANG_##NAME: \
|
|
|
|
return LOWER_BOUND;
|
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::CaseString(unsigned Case) {
|
2009-12-30 05:09:57 +08:00
|
|
|
switch (Case) {
|
2017-06-07 11:48:56 +08:00
|
|
|
case DW_ID_case_sensitive:
|
|
|
|
return "DW_ID_case_sensitive";
|
|
|
|
case DW_ID_up_case:
|
|
|
|
return "DW_ID_up_case";
|
|
|
|
case DW_ID_down_case:
|
|
|
|
return "DW_ID_down_case";
|
|
|
|
case DW_ID_case_insensitive:
|
|
|
|
return "DW_ID_case_insensitive";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::ConventionString(unsigned CC) {
|
2016-06-09 04:34:29 +08:00
|
|
|
switch (CC) {
|
|
|
|
default:
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2017-06-07 11:48:56 +08:00
|
|
|
#define HANDLE_DW_CC(ID, NAME) \
|
|
|
|
case DW_CC_##NAME: \
|
2016-06-09 04:34:29 +08:00
|
|
|
return "DW_CC_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-06-09 04:34:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned llvm::dwarf::getCallingConvention(StringRef CCString) {
|
|
|
|
return StringSwitch<unsigned>(CCString)
|
|
|
|
#define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME)
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2016-06-09 04:34:29 +08:00
|
|
|
.Default(0);
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::InlineCodeString(unsigned Code) {
|
2009-12-30 05:09:57 +08:00
|
|
|
switch (Code) {
|
2017-06-07 11:48:56 +08:00
|
|
|
case DW_INL_not_inlined:
|
|
|
|
return "DW_INL_not_inlined";
|
|
|
|
case DW_INL_inlined:
|
|
|
|
return "DW_INL_inlined";
|
|
|
|
case DW_INL_declared_not_inlined:
|
|
|
|
return "DW_INL_declared_not_inlined";
|
|
|
|
case DW_INL_declared_inlined:
|
|
|
|
return "DW_INL_declared_inlined";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::ArrayOrderString(unsigned Order) {
|
2009-12-30 05:09:57 +08:00
|
|
|
switch (Order) {
|
2017-06-07 11:48:56 +08:00
|
|
|
case DW_ORD_row_major:
|
|
|
|
return "DW_ORD_row_major";
|
|
|
|
case DW_ORD_col_major:
|
|
|
|
return "DW_ORD_col_major";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::LNStandardString(unsigned Standard) {
|
2009-12-30 05:09:57 +08:00
|
|
|
switch (Standard) {
|
2016-10-29 06:56:59 +08:00
|
|
|
default:
|
|
|
|
return StringRef();
|
2017-06-07 11:48:56 +08:00
|
|
|
#define HANDLE_DW_LNS(ID, NAME) \
|
|
|
|
case DW_LNS_##NAME: \
|
2016-10-29 06:56:59 +08:00
|
|
|
return "DW_LNS_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) {
|
2009-12-30 05:09:57 +08:00
|
|
|
switch (Encoding) {
|
2016-10-29 06:57:02 +08:00
|
|
|
default:
|
|
|
|
return StringRef();
|
2017-06-07 11:48:56 +08:00
|
|
|
#define HANDLE_DW_LNE(ID, NAME) \
|
|
|
|
case DW_LNE_##NAME: \
|
2016-10-29 06:57:02 +08:00
|
|
|
return "DW_LNE_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::MacinfoString(unsigned Encoding) {
|
2009-12-30 05:09:57 +08:00
|
|
|
switch (Encoding) {
|
|
|
|
// Macinfo Type Encodings
|
2017-06-07 11:48:56 +08:00
|
|
|
case DW_MACINFO_define:
|
|
|
|
return "DW_MACINFO_define";
|
|
|
|
case DW_MACINFO_undef:
|
|
|
|
return "DW_MACINFO_undef";
|
|
|
|
case DW_MACINFO_start_file:
|
|
|
|
return "DW_MACINFO_start_file";
|
|
|
|
case DW_MACINFO_end_file:
|
|
|
|
return "DW_MACINFO_end_file";
|
|
|
|
case DW_MACINFO_vendor_ext:
|
|
|
|
return "DW_MACINFO_vendor_ext";
|
|
|
|
case DW_MACINFO_invalid:
|
|
|
|
return "DW_MACINFO_invalid";
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
|
2015-12-10 20:56:35 +08:00
|
|
|
unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) {
|
|
|
|
return StringSwitch<unsigned>(MacinfoString)
|
|
|
|
.Case("DW_MACINFO_define", DW_MACINFO_define)
|
|
|
|
.Case("DW_MACINFO_undef", DW_MACINFO_undef)
|
|
|
|
.Case("DW_MACINFO_start_file", DW_MACINFO_start_file)
|
|
|
|
.Case("DW_MACINFO_end_file", DW_MACINFO_end_file)
|
|
|
|
.Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext)
|
|
|
|
.Default(DW_MACINFO_invalid);
|
|
|
|
}
|
|
|
|
|
2018-03-09 04:52:35 +08:00
|
|
|
StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) {
|
|
|
|
switch (Encoding) {
|
|
|
|
default:
|
|
|
|
return StringRef();
|
|
|
|
#define HANDLE_DW_RLE(ID, NAME) \
|
|
|
|
case DW_RLE_##NAME: \
|
|
|
|
return "DW_RLE_" #NAME;
|
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-18 18:37:42 +08:00
|
|
|
StringRef llvm::dwarf::CallFrameString(unsigned Encoding,
|
|
|
|
Triple::ArchType Arch) {
|
|
|
|
assert(Arch != llvm::Triple::ArchType::UnknownArch);
|
|
|
|
#define SELECT_AARCH64 (Arch == llvm::Triple::aarch64_be || Arch == llvm::Triple::aarch64)
|
|
|
|
#define SELECT_MIPS64 Arch == llvm::Triple::mips64
|
|
|
|
#define SELECT_SPARC (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9)
|
|
|
|
#define SELECT_X86 (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64)
|
|
|
|
#define HANDLE_DW_CFA(ID, NAME)
|
|
|
|
#define HANDLE_DW_CFA_PRED(ID, NAME, PRED) \
|
|
|
|
if (ID == Encoding && PRED) \
|
|
|
|
return "DW_CFA_" #NAME;
|
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
|
|
|
|
2009-12-30 05:09:57 +08:00
|
|
|
switch (Encoding) {
|
2016-10-29 06:56:53 +08:00
|
|
|
default:
|
|
|
|
return StringRef();
|
2018-12-18 18:37:42 +08:00
|
|
|
#define HANDLE_DW_CFA_PRED(ID, NAME, PRED)
|
2017-06-07 11:48:56 +08:00
|
|
|
#define HANDLE_DW_CFA(ID, NAME) \
|
|
|
|
case DW_CFA_##NAME: \
|
2016-10-29 06:56:53 +08:00
|
|
|
return "DW_CFA_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2018-12-18 18:37:42 +08:00
|
|
|
|
|
|
|
#undef SELECT_X86
|
|
|
|
#undef SELECT_SPARC
|
|
|
|
#undef SELECT_MIPS64
|
|
|
|
#undef SELECT_AARCH64
|
2006-02-27 20:43:29 +08:00
|
|
|
}
|
|
|
|
}
|
2013-09-06 02:20:16 +08:00
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) {
|
2014-10-10 04:43:04 +08:00
|
|
|
switch (Prop) {
|
2016-10-29 06:56:56 +08:00
|
|
|
default:
|
|
|
|
return StringRef();
|
2017-06-07 11:48:56 +08:00
|
|
|
#define HANDLE_DW_APPLE_PROPERTY(ID, NAME) \
|
|
|
|
case DW_APPLE_PROPERTY_##NAME: \
|
2016-10-29 06:56:56 +08:00
|
|
|
return "DW_APPLE_PROPERTY_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2014-10-10 04:43:04 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-01 04:24:55 +08:00
|
|
|
StringRef llvm::dwarf::UnitTypeString(unsigned UT) {
|
|
|
|
switch (UT) {
|
|
|
|
default:
|
|
|
|
return StringRef();
|
|
|
|
#define HANDLE_DW_UT(ID, NAME) \
|
|
|
|
case DW_UT_##NAME: \
|
|
|
|
return "DW_UT_" #NAME;
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
2017-03-01 04:24:55 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::AtomTypeString(unsigned AT) {
|
2013-09-06 02:20:16 +08:00
|
|
|
switch (AT) {
|
|
|
|
case dwarf::DW_ATOM_null:
|
|
|
|
return "DW_ATOM_null";
|
|
|
|
case dwarf::DW_ATOM_die_offset:
|
|
|
|
return "DW_ATOM_die_offset";
|
|
|
|
case DW_ATOM_cu_offset:
|
|
|
|
return "DW_ATOM_cu_offset";
|
|
|
|
case DW_ATOM_die_tag:
|
|
|
|
return "DW_ATOM_die_tag";
|
|
|
|
case DW_ATOM_type_flags:
|
2018-01-25 19:19:08 +08:00
|
|
|
case DW_ATOM_type_type_flags:
|
2013-09-06 02:20:16 +08:00
|
|
|
return "DW_ATOM_type_flags";
|
2018-01-25 19:19:08 +08:00
|
|
|
case DW_ATOM_qual_name_hash:
|
|
|
|
return "DW_ATOM_qual_name_hash";
|
2013-09-06 02:20:16 +08:00
|
|
|
}
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2013-09-06 02:20:16 +08:00
|
|
|
}
|
2013-09-20 06:19:37 +08:00
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) {
|
2013-09-20 06:19:37 +08:00
|
|
|
switch (Kind) {
|
|
|
|
case GIEK_NONE:
|
|
|
|
return "NONE";
|
|
|
|
case GIEK_TYPE:
|
|
|
|
return "TYPE";
|
|
|
|
case GIEK_VARIABLE:
|
|
|
|
return "VARIABLE";
|
|
|
|
case GIEK_FUNCTION:
|
|
|
|
return "FUNCTION";
|
|
|
|
case GIEK_OTHER:
|
|
|
|
return "OTHER";
|
|
|
|
case GIEK_UNUSED5:
|
|
|
|
return "UNUSED5";
|
|
|
|
case GIEK_UNUSED6:
|
|
|
|
return "UNUSED6";
|
|
|
|
case GIEK_UNUSED7:
|
|
|
|
return "UNUSED7";
|
|
|
|
}
|
|
|
|
llvm_unreachable("Unknown GDBIndexEntryKind value");
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef
|
|
|
|
llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) {
|
2013-09-20 06:19:37 +08:00
|
|
|
switch (Linkage) {
|
|
|
|
case GIEL_EXTERNAL:
|
|
|
|
return "EXTERNAL";
|
|
|
|
case GIEL_STATIC:
|
|
|
|
return "STATIC";
|
|
|
|
}
|
|
|
|
llvm_unreachable("Unknown GDBIndexEntryLinkage value");
|
|
|
|
}
|
2014-09-05 03:39:20 +08:00
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) {
|
2014-09-05 03:39:20 +08:00
|
|
|
switch (Attr) {
|
|
|
|
case DW_AT_accessibility:
|
|
|
|
return AccessibilityString(Val);
|
|
|
|
case DW_AT_virtuality:
|
|
|
|
return VirtualityString(Val);
|
|
|
|
case DW_AT_language:
|
|
|
|
return LanguageString(Val);
|
|
|
|
case DW_AT_encoding:
|
|
|
|
return AttributeEncodingString(Val);
|
|
|
|
case DW_AT_decimal_sign:
|
|
|
|
return DecimalSignString(Val);
|
|
|
|
case DW_AT_endianity:
|
|
|
|
return EndianityString(Val);
|
|
|
|
case DW_AT_visibility:
|
|
|
|
return VisibilityString(Val);
|
|
|
|
case DW_AT_identifier_case:
|
|
|
|
return CaseString(Val);
|
|
|
|
case DW_AT_calling_convention:
|
|
|
|
return ConventionString(Val);
|
|
|
|
case DW_AT_inline:
|
|
|
|
return InlineCodeString(Val);
|
|
|
|
case DW_AT_ordering:
|
|
|
|
return ArrayOrderString(Val);
|
2018-07-14 00:06:17 +08:00
|
|
|
case DW_AT_APPLE_runtime_class:
|
|
|
|
return LanguageString(Val);
|
2014-09-05 03:39:20 +08:00
|
|
|
}
|
|
|
|
|
2018-07-14 01:21:51 +08:00
|
|
|
return StringRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
StringRef llvm::dwarf::AtomValueString(uint16_t Atom, unsigned Val) {
|
|
|
|
switch (Atom) {
|
|
|
|
case DW_ATOM_null:
|
|
|
|
return "NULL";
|
|
|
|
case DW_ATOM_die_tag:
|
|
|
|
return TagString(Val);
|
|
|
|
}
|
|
|
|
|
2016-10-05 13:59:29 +08:00
|
|
|
return StringRef();
|
2014-09-05 03:39:20 +08:00
|
|
|
}
|
2017-04-21 03:16:51 +08:00
|
|
|
|
2018-01-22 17:41:36 +08:00
|
|
|
StringRef llvm::dwarf::IndexString(unsigned Idx) {
|
|
|
|
switch (Idx) {
|
|
|
|
default:
|
|
|
|
return StringRef();
|
|
|
|
#define HANDLE_DW_IDX(ID, NAME) \
|
|
|
|
case DW_IDX_##NAME: \
|
|
|
|
return "DW_IDX_" #NAME;
|
|
|
|
#include "llvm/BinaryFormat/Dwarf.def"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-14 17:39:54 +08:00
|
|
|
Optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form,
|
|
|
|
FormParams Params) {
|
|
|
|
switch (Form) {
|
|
|
|
case DW_FORM_addr:
|
|
|
|
if (Params)
|
|
|
|
return Params.AddrSize;
|
|
|
|
return None;
|
|
|
|
|
|
|
|
case DW_FORM_block: // ULEB128 length L followed by L bytes.
|
|
|
|
case DW_FORM_block1: // 1 byte length L followed by L bytes.
|
|
|
|
case DW_FORM_block2: // 2 byte length L followed by L bytes.
|
|
|
|
case DW_FORM_block4: // 4 byte length L followed by L bytes.
|
|
|
|
case DW_FORM_string: // C-string with null terminator.
|
|
|
|
case DW_FORM_sdata: // SLEB128.
|
|
|
|
case DW_FORM_udata: // ULEB128.
|
|
|
|
case DW_FORM_ref_udata: // ULEB128.
|
|
|
|
case DW_FORM_indirect: // ULEB128.
|
|
|
|
case DW_FORM_exprloc: // ULEB128 length L followed by L bytes.
|
|
|
|
case DW_FORM_strx: // ULEB128.
|
|
|
|
case DW_FORM_addrx: // ULEB128.
|
|
|
|
case DW_FORM_loclistx: // ULEB128.
|
|
|
|
case DW_FORM_rnglistx: // ULEB128.
|
|
|
|
case DW_FORM_GNU_addr_index: // ULEB128.
|
|
|
|
case DW_FORM_GNU_str_index: // ULEB128.
|
|
|
|
return None;
|
|
|
|
|
|
|
|
case DW_FORM_ref_addr:
|
|
|
|
if (Params)
|
|
|
|
return Params.getRefAddrByteSize();
|
|
|
|
return None;
|
|
|
|
|
|
|
|
case DW_FORM_flag:
|
|
|
|
case DW_FORM_data1:
|
|
|
|
case DW_FORM_ref1:
|
|
|
|
case DW_FORM_strx1:
|
|
|
|
case DW_FORM_addrx1:
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case DW_FORM_data2:
|
|
|
|
case DW_FORM_ref2:
|
|
|
|
case DW_FORM_strx2:
|
|
|
|
case DW_FORM_addrx2:
|
|
|
|
return 2;
|
|
|
|
|
|
|
|
case DW_FORM_strx3:
|
|
|
|
return 3;
|
|
|
|
|
|
|
|
case DW_FORM_data4:
|
|
|
|
case DW_FORM_ref4:
|
|
|
|
case DW_FORM_ref_sup4:
|
|
|
|
case DW_FORM_strx4:
|
|
|
|
case DW_FORM_addrx4:
|
|
|
|
return 4;
|
|
|
|
|
|
|
|
case DW_FORM_strp:
|
|
|
|
case DW_FORM_GNU_ref_alt:
|
|
|
|
case DW_FORM_GNU_strp_alt:
|
|
|
|
case DW_FORM_line_strp:
|
|
|
|
case DW_FORM_sec_offset:
|
|
|
|
case DW_FORM_strp_sup:
|
|
|
|
if (Params)
|
|
|
|
return Params.getDwarfOffsetByteSize();
|
|
|
|
return None;
|
|
|
|
|
|
|
|
case DW_FORM_data8:
|
|
|
|
case DW_FORM_ref8:
|
|
|
|
case DW_FORM_ref_sig8:
|
|
|
|
case DW_FORM_ref_sup8:
|
|
|
|
return 8;
|
|
|
|
|
|
|
|
case DW_FORM_flag_present:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case DW_FORM_data16:
|
|
|
|
return 16;
|
|
|
|
|
|
|
|
case DW_FORM_implicit_const:
|
|
|
|
// The implicit value is stored in the abbreviation as a SLEB128, and
|
|
|
|
// there no data in debug info.
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
2017-04-21 03:16:51 +08:00
|
|
|
bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
|
|
|
|
bool ExtensionsOk) {
|
|
|
|
if (FormVendor(F) == DWARF_VENDOR_DWARF) {
|
|
|
|
unsigned FV = FormVersion(F);
|
|
|
|
return FV > 0 && FV <= Version;
|
|
|
|
}
|
|
|
|
return ExtensionsOk;
|
|
|
|
}
|
[dwarf] Unify unknown dwarf enum formatting code
Summary:
We have had at least three pieces of code (in DWARFAbbreviationDeclaration,
DWARFAcceleratorTable and DWARFDie) that have hand-rolled support for
dumping unknown dwarf enum values. While not terrible, they are a bit
distracting and enable small differences to creep in (Unknown_ffff vs.
Unknown_0xffff). I ended up needing to add a fourth place
(DWARFVerifier), so it seems it would be a good time to centralize.
This patch creates an alternative to the XXXString dumping functions in
the BinaryFormat library, which formats an unknown value as
DW_TYPE_unknown_1234, instead of just an empty string. It is based on
the formatv function, as that allows us to avoid materializing the
string for unknown values (and because this way I don't have to invent a
name for the new functions :P).
In this patch I add formatters for dwarf attributes, forms, tags, and
index attributes as these are the ones in use currently, but adding
other enums is straight-forward.
Reviewers: dblaikie, JDevlieghere, aprantl
Subscribers: llvm-commits
Differential Revision: https://reviews.llvm.org/D44570
llvm-svn: 328090
2018-03-21 19:46:37 +08:00
|
|
|
|
2018-03-21 20:18:03 +08:00
|
|
|
constexpr char llvm::dwarf::EnumTraits<Attribute>::Type[];
|
|
|
|
constexpr char llvm::dwarf::EnumTraits<Form>::Type[];
|
|
|
|
constexpr char llvm::dwarf::EnumTraits<Index>::Type[];
|
|
|
|
constexpr char llvm::dwarf::EnumTraits<Tag>::Type[];
|