Add support for fixed-point types #129596
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-llvm-ir @llvm/pr-subscribers-debuginfo Author: Tom Tromey (tromey) ChangesThis adds DWARF generation for fixed-point types. This feature is needed by Ada. Note that a pre-existing GNU extension is used in one case. This has been emitted by GCC for years, and is needed because standard DWARF is otherwise incapable of representing these types. Patch is 35.67 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/129596.diff 19 Files Affected:
diff --git a/llvm/include/llvm-c/DebugInfo.h b/llvm/include/llvm-c/DebugInfo.h
index 9d0875a4ed8d8..3ecd642e08958 100644
--- a/llvm/include/llvm-c/DebugInfo.h
+++ b/llvm/include/llvm-c/DebugInfo.h
@@ -171,6 +171,7 @@ enum {
LLVMDISubrangeMetadataKind,
LLVMDIEnumeratorMetadataKind,
LLVMDIBasicTypeMetadataKind,
+ LLVMDIFixedPointTypeMetadataKind,
LLVMDIDerivedTypeMetadataKind,
LLVMDISubrangeTypeMetadataKind,
LLVMDICompositeTypeMetadataKind,
diff --git a/llvm/include/llvm/AsmParser/LLToken.h b/llvm/include/llvm/AsmParser/LLToken.h
index 81b9929b1fab8..a8f9c71781701 100644
--- a/llvm/include/llvm/AsmParser/LLToken.h
+++ b/llvm/include/llvm/AsmParser/LLToken.h
@@ -494,6 +494,7 @@ enum Kind {
DwarfCC, // DW_CC_foo
EmissionKind, // lineTablesOnly
NameTableKind, // GNU
+ FixedPointKind, // Fixed point
DwarfOp, // DW_OP_foo
DIFlag, // DIFlagFoo
DISPFlag, // DISPFlagFoo
diff --git a/llvm/include/llvm/Bitcode/LLVMBitCodes.h b/llvm/include/llvm/Bitcode/LLVMBitCodes.h
index ec2535ac85966..92b6e68d9d0a7 100644
--- a/llvm/include/llvm/Bitcode/LLVMBitCodes.h
+++ b/llvm/include/llvm/Bitcode/LLVMBitCodes.h
@@ -386,6 +386,7 @@ enum MetadataCodes {
METADATA_ARG_LIST = 46, // [n x [type num, value num]]
METADATA_ASSIGN_ID = 47, // [distinct, ...]
METADATA_SUBRANGE_TYPE = 48, // [distinct, ...]
+ METADATA_FIXED_POINT_TYPE = 49, // [distinct, ...]
};
// The constants block (CONSTANTS_BLOCK_ID) describes emission for each
diff --git a/llvm/include/llvm/IR/DIBuilder.h b/llvm/include/llvm/IR/DIBuilder.h
index 92a0b7a16d039..2e624b8d816ae 100644
--- a/llvm/include/llvm/IR/DIBuilder.h
+++ b/llvm/include/llvm/IR/DIBuilder.h
@@ -215,6 +215,42 @@ namespace llvm {
DINode::DIFlags Flags = DINode::FlagZero,
uint32_t NumExtraInhabitants = 0);
+ /// Create debugging information entry for a binary fixed-point type.
+ /// \param Name Type name.
+ /// \param Encoding DWARF encoding code, either
+ /// dwarf::DW_ATE_signed_fixed or DW_ATE_unsigned_fixed.
+ /// \param Flags Optional DWARF attributes, e.g., DW_AT_endianity.
+ /// \param Factor Binary scale factor.
+ DIFixedPointType *
+ createBinaryFixedPointType(StringRef Name, uint64_t SizeInBits,
+ uint32_t AlignInBits, unsigned Encoding,
+ DINode::DIFlags Flags, int Factor);
+
+ /// Create debugging information entry for a decimal fixed-point type.
+ /// \param Name Type name.
+ /// \param Encoding DWARF encoding code, either
+ /// dwarf::DW_ATE_signed_fixed or DW_ATE_unsigned_fixed.
+ /// \param Flags Optional DWARF attributes, e.g., DW_AT_endianity.
+ /// \param Factor Decimal scale factor.
+ DIFixedPointType *
+ createDecimalFixedPointType(StringRef Name, uint64_t SizeInBits,
+ uint32_t AlignInBits, unsigned Encoding,
+ DINode::DIFlags Flags, int Factor);
+
+ /// Create debugging information entry for an arbitrary rational
+ /// fixed-point type.
+ /// \param Name Type name.
+ /// \param Encoding DWARF encoding code, either
+ /// dwarf::DW_ATE_signed_fixed or DW_ATE_unsigned_fixed.
+ /// \param Flags Optional DWARF attributes, e.g., DW_AT_endianity.
+ /// \param Numerator Numerator of scale factor.
+ /// \param Denominator Denominator of scale factor.
+ DIFixedPointType *
+ createRationalFixedPointType(StringRef Name, uint64_t SizeInBits,
+ uint32_t AlignInBits, unsigned Encoding,
+ DINode::DIFlags Flags, APInt Numerator,
+ APInt Denominator);
+
/// Create debugging information entry for a string
/// type.
/// \param Name Type name.
diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h
index 7826514cd3e44..1e91265332ef5 100644
--- a/llvm/include/llvm/IR/DebugInfoMetadata.h
+++ b/llvm/include/llvm/IR/DebugInfoMetadata.h
@@ -199,6 +199,7 @@ class DINode : public MDNode {
case DISubrangeKind:
case DIEnumeratorKind:
case DIBasicTypeKind:
+ case DIFixedPointTypeKind:
case DIStringTypeKind:
case DISubrangeTypeKind:
case DIDerivedTypeKind:
@@ -547,6 +548,7 @@ class DIScope : public DINode {
default:
return false;
case DIBasicTypeKind:
+ case DIFixedPointTypeKind:
case DIStringTypeKind:
case DISubrangeTypeKind:
case DIDerivedTypeKind:
@@ -806,6 +808,7 @@ class DIType : public DIScope {
default:
return false;
case DIBasicTypeKind:
+ case DIFixedPointTypeKind:
case DIStringTypeKind:
case DISubrangeTypeKind:
case DIDerivedTypeKind:
@@ -826,6 +829,7 @@ class DIBasicType : public DIType {
unsigned Encoding;
+protected:
DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
uint32_t NumExtraInhabitants, DIFlags Flags,
@@ -833,6 +837,13 @@ class DIBasicType : public DIType {
: DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
NumExtraInhabitants, Flags, Ops),
Encoding(Encoding) {}
+ DIBasicType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
+ uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
+ uint32_t NumExtraInhabitants, DIFlags Flags,
+ ArrayRef<Metadata *> Ops)
+ : DIType(C, ID, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
+ NumExtraInhabitants, Flags, Ops),
+ Encoding(Encoding) {}
~DIBasicType() = default;
static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
@@ -897,7 +908,132 @@ class DIBasicType : public DIType {
std::optional<Signedness> getSignedness() const;
static bool classof(const Metadata *MD) {
- return MD->getMetadataID() == DIBasicTypeKind;
+ return MD->getMetadataID() == DIBasicTypeKind ||
+ MD->getMetadataID() == DIFixedPointTypeKind;
+ }
+};
+
+/// Fixed-point type.
+class DIFixedPointType : public DIBasicType {
+ friend class LLVMContextImpl;
+ friend class MDNode;
+
+ // Actually FixedPointKind.
+ unsigned Kind;
+ // Used for binary and decimal.
+ int Factor;
+ // Used for rational.
+ APInt Numerator;
+ APInt Denominator;
+
+ DIFixedPointType(LLVMContext &C, StorageType Storage, unsigned Tag,
+ uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
+ DIFlags Flags, unsigned Kind, int Factor,
+ ArrayRef<Metadata *> Ops)
+ : DIBasicType(C, DIFixedPointTypeKind, Storage, Tag, SizeInBits,
+ AlignInBits, Encoding, 0, Flags, Ops),
+ Kind(Kind), Factor(Factor) {
+ assert(Kind == FixedPointBinary || Kind == FixedPointDecimal);
+ }
+ DIFixedPointType(LLVMContext &C, StorageType Storage, unsigned Tag,
+ uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
+ DIFlags Flags, unsigned Kind, APInt Numerator,
+ APInt Denominator, ArrayRef<Metadata *> Ops)
+ : DIBasicType(C, DIFixedPointTypeKind, Storage, Tag, SizeInBits,
+ AlignInBits, Encoding, 0, Flags, Ops),
+ Kind(Kind), Factor(0), Numerator(Numerator), Denominator(Denominator) {
+ assert(Kind == FixedPointRational);
+ }
+ DIFixedPointType(LLVMContext &C, StorageType Storage, unsigned Tag,
+ uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
+ DIFlags Flags, unsigned Kind, int Factor, APInt Numerator,
+ APInt Denominator, ArrayRef<Metadata *> Ops)
+ : DIBasicType(C, DIFixedPointTypeKind, Storage, Tag, SizeInBits,
+ AlignInBits, Encoding, 0, Flags, Ops),
+ Kind(Kind), Factor(Factor), Numerator(Numerator),
+ Denominator(Denominator) {}
+ ~DIFixedPointType() = default;
+
+ static DIFixedPointType *
+ getImpl(LLVMContext &Context, unsigned Tag, StringRef Name,
+ uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
+ DIFlags Flags, unsigned Kind, int Factor, APInt Numerator,
+ APInt Denominator, StorageType Storage, bool ShouldCreate = true) {
+ return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
+ SizeInBits, AlignInBits, Encoding, Flags, Kind, Factor,
+ Numerator, Denominator, Storage, ShouldCreate);
+ }
+ static DIFixedPointType *
+ getImpl(LLVMContext &Context, unsigned Tag, MDString *Name,
+ uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
+ DIFlags Flags, unsigned Kind, int Factor, APInt Numerator,
+ APInt Denominator, StorageType Storage, bool ShouldCreate = true);
+
+ TempDIFixedPointType cloneImpl() const {
+ return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
+ getAlignInBits(), getEncoding(), getFlags(), Kind,
+ Factor, Numerator, Denominator);
+ }
+
+public:
+ enum FixedPointKind : unsigned {
+ /// Scale factor 2^Factor.
+ FixedPointBinary,
+ /// Scale factor 10^Factor.
+ FixedPointDecimal,
+ /// Arbitrary rational scale factor.
+ FixedPointRational,
+ LastFixedPointKind = FixedPointRational,
+ };
+
+ static std::optional<FixedPointKind> getFixedPointKind(StringRef Str);
+ static const char *fixedPointKindString(FixedPointKind);
+
+ DEFINE_MDNODE_GET(DIFixedPointType,
+ (unsigned Tag, MDString *Name, uint64_t SizeInBits,
+ uint32_t AlignInBits, unsigned Encoding, DIFlags Flags,
+ unsigned Kind, int Factor, APInt Numerator,
+ APInt Denominator),
+ (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags, Kind,
+ Factor, Numerator, Denominator))
+ DEFINE_MDNODE_GET(DIFixedPointType,
+ (unsigned Tag, StringRef Name, uint64_t SizeInBits,
+ uint32_t AlignInBits, unsigned Encoding, DIFlags Flags,
+ unsigned Kind, int Factor, APInt Numerator,
+ APInt Denominator),
+ (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags, Kind,
+ Factor, Numerator, Denominator))
+
+ TempDIFixedPointType clone() const { return cloneImpl(); }
+
+ bool isBinary() const { return Kind == FixedPointBinary; }
+ bool isDecimal() const { return Kind == FixedPointDecimal; }
+ bool isRational() const { return Kind == FixedPointRational; }
+
+ bool isSigned() const;
+
+ FixedPointKind getKind() const { return static_cast<FixedPointKind>(Kind); }
+
+ int getFactorRaw() const { return Factor; }
+ int getFactor() const {
+ assert(Kind == FixedPointBinary || Kind == FixedPointDecimal);
+ return Factor;
+ }
+
+ const APInt &getNumeratorRaw() const { return Numerator; }
+ const APInt &getNumerator() const {
+ assert(Kind == FixedPointRational);
+ return Numerator;
+ }
+
+ const APInt &getDenominatorRaw() const { return Denominator; }
+ const APInt &getDenominator() const {
+ assert(Kind == FixedPointRational);
+ return Denominator;
+ }
+
+ static bool classof(const Metadata *MD) {
+ return MD->getMetadataID() == DIFixedPointTypeKind;
}
};
diff --git a/llvm/include/llvm/IR/Metadata.def b/llvm/include/llvm/IR/Metadata.def
index 7cb257fefbc38..511bf48707f00 100644
--- a/llvm/include/llvm/IR/Metadata.def
+++ b/llvm/include/llvm/IR/Metadata.def
@@ -119,6 +119,7 @@ HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICommonBlock)
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIStringType)
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGenericSubrange)
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubrangeType)
+HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIFixedPointType)
#undef HANDLE_METADATA
#undef HANDLE_METADATA_LEAF
diff --git a/llvm/lib/AsmParser/LLLexer.cpp b/llvm/lib/AsmParser/LLLexer.cpp
index fd0a50d25e714..4d25b12c9ab06 100644
--- a/llvm/lib/AsmParser/LLLexer.cpp
+++ b/llvm/lib/AsmParser/LLLexer.cpp
@@ -1024,6 +1024,11 @@ lltok::Kind LLLexer::LexIdentifier() {
return lltok::NameTableKind;
}
+ if (Keyword == "Binary" || Keyword == "Decimal" || Keyword == "Rational") {
+ StrVal.assign(Keyword.begin(), Keyword.end());
+ return lltok::FixedPointKind;
+ }
+
// Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
// the CFE to avoid forcing it to deal with 64-bit numbers.
if ((TokStart[0] == 'u' || TokStart[0] == 's') &&
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index 777bf5f7bb386..cef1a545af0cd 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -4750,6 +4750,11 @@ struct EmissionKindField : public MDUnsignedField {
EmissionKindField() : MDUnsignedField(0, DICompileUnit::LastEmissionKind) {}
};
+struct FixedPointKindField : public MDUnsignedField {
+ FixedPointKindField()
+ : MDUnsignedField(0, DIFixedPointType::LastFixedPointKind) {}
+};
+
struct NameTableKindField : public MDUnsignedField {
NameTableKindField()
: MDUnsignedField(
@@ -4993,6 +4998,25 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
return false;
}
+template <>
+bool LLParser::parseMDField(LocTy Loc, StringRef Name,
+ FixedPointKindField &Result) {
+ if (Lex.getKind() == lltok::APSInt)
+ return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+
+ if (Lex.getKind() != lltok::FixedPointKind)
+ return tokError("expected fixed-point kind");
+
+ auto Kind = DIFixedPointType::getFixedPointKind(Lex.getStrVal());
+ if (!Kind)
+ return tokError("invalid fixed-point kind" + Twine(" '") + Lex.getStrVal() +
+ "'");
+ assert(*Kind <= Result.Max && "Expected valid fixed-point kind");
+ Result.assign(*Kind);
+ Lex.Lex();
+ return false;
+}
+
template <>
bool LLParser::parseMDField(LocTy Loc, StringRef Name,
NameTableKindField &Result) {
@@ -5515,6 +5539,33 @@ bool LLParser::parseDIBasicType(MDNode *&Result, bool IsDistinct) {
return false;
}
+/// parseDIFixedPointType:
+/// ::= !DIFixedPointType(tag: DW_TAG_base_type, name: "xyz", size: 32, align:
+/// 32,
+/// encoding: DW_ATE_signed_fixed, flags: 0,
+/// kind: 2, factor: 3, numerator: 1, denominator: 8)
+bool LLParser::parseDIFixedPointType(MDNode *&Result, bool IsDistinct) {
+#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
+ OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type)); \
+ OPTIONAL(name, MDStringField, ); \
+ OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
+ OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
+ OPTIONAL(encoding, DwarfAttEncodingField, ); \
+ OPTIONAL(flags, DIFlagField, ); \
+ OPTIONAL(kind, FixedPointKindField, ); \
+ OPTIONAL(factor, MDSignedField, ); \
+ OPTIONAL(numerator, MDAPSIntField, ); \
+ OPTIONAL(denominator, MDAPSIntField, );
+ PARSE_MD_FIELDS();
+#undef VISIT_MD_FIELDS
+
+ Result = GET_OR_DISTINCT(DIFixedPointType,
+ (Context, tag.Val, name.Val, size.Val, align.Val,
+ encoding.Val, flags.Val, kind.Val, factor.Val,
+ numerator.Val, denominator.Val));
+ return false;
+}
+
/// parseDIStringType:
/// ::= !DIStringType(name: "character(4)", size: 32, align: 32)
bool LLParser::parseDIStringType(MDNode *&Result, bool IsDistinct) {
diff --git a/llvm/lib/Bitcode/Reader/MetadataLoader.cpp b/llvm/lib/Bitcode/Reader/MetadataLoader.cpp
index 1baf0a9214e00..7e078f6f7f044 100644
--- a/llvm/lib/Bitcode/Reader/MetadataLoader.cpp
+++ b/llvm/lib/Bitcode/Reader/MetadataLoader.cpp
@@ -1542,6 +1542,39 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
NextMetadataNo++;
break;
}
+ case bitc::METADATA_FIXED_POINT_TYPE: {
+ if (Record.size() < 11)
+ return error("Invalid record");
+
+ IsDistinct = Record[0];
+ DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[6]);
+
+ size_t Offset = 9;
+
+ auto ReadWideInt = [&]() {
+ uint64_t Encoded = Record[Offset++];
+ unsigned NumWords = Encoded >> 32;
+ unsigned BitWidth = Encoded & 0xffffffff;
+ auto Value = readWideAPInt(ArrayRef(&Record[Offset], NumWords), BitWidth);
+ Offset += NumWords;
+ return Value;
+ };
+
+ APInt Numerator = ReadWideInt();
+ APInt Denominator = ReadWideInt();
+
+ if (Offset != Record.size())
+ return error("Invalid record");
+
+ MetadataList.assignValue(
+ GET_OR_DISTINCT(DIFixedPointType,
+ (Context, Record[1], getMDString(Record[2]), Record[3],
+ Record[4], Record[5], Flags, Record[7], Record[8],
+ Numerator, Denominator)),
+ NextMetadataNo);
+ NextMetadataNo++;
+ break;
+ }
case bitc::METADATA_STRING_TYPE: {
if (Record.size() > 9 || Record.size() < 8)
return error("Invalid record");
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index 440a2c9ace8a3..91d1f931fce39 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -323,6 +323,9 @@ class ModuleBitcodeWriter : public ModuleBitcodeWriterBase {
SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
void writeDIBasicType(const DIBasicType *N, SmallVectorImpl<uint64_t> &Record,
unsigned Abbrev);
+ void writeDIFixedPointType(const DIFixedPointType *N,
+ SmallVectorImpl<uint64_t> &Record,
+ unsigned Abbrev);
void writeDIStringType(const DIStringType *N,
SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
void writeDIDerivedType(const DIDerivedType *N,
@@ -1888,6 +1891,35 @@ void ModuleBitcodeWriter::writeDIBasicType(const DIBasicType *N,
Record.clear();
}
+void ModuleBitcodeWriter::writeDIFixedPointType(
+ const DIFixedPointType *N, SmallVectorImpl<uint64_t> &Record,
+ unsigned Abbrev) {
+ Record.push_back(N->isDistinct());
+ Record.push_back(N->getTag());
+ Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
+ Record.push_back(N->getSizeInBits());
+ Record.push_back(N->getAlignInBits());
+ Record.push_back(N->getEncoding());
+ Record.push_back(N->getFlags());
+ Record.push_back(N->getKind());
+ Record.push_back(N->getFactorRaw());
+
+ auto WriteWideInt = [&](const APInt &Value) {
+ // Write an encoded word that holds the number of active words and
+ // the number of bits.
+ uint64_t NumWords = Value.getActiveWords();
+ uint64_t Encoded = (NumWords << 32) | Value.getBitWidth();
+ Record.push_back(Encoded);
+ emitWideAPInt(Record, Value);
+ };
+
+ WriteWideInt(N->getNumeratorRaw());
+ WriteWideInt(N->getDenominatorRaw());
+
+ Stream.EmitRecord(bitc::METADATA_FIXED_POINT_TYPE, Record, Abbrev);
+ Record.clear();
+}
+
void ModuleBitcodeWriter::writeDIStringType(const DIStringType *N,
SmallVectorImpl<uint64_t> &Record,
unsigned Abbrev) {
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
index b77ecf1372405..bf8bfcab0679e 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
@@ -615,7 +615,9 @@ DIE *DwarfUnit::createTypeDIE(const DIScope *Context, DIE &ContextDIE,
return &TyDIE;
}
construct(CTy);
- } else if (auto *BT = dyn_cast<DIBasicType>(Ty))
+ } else if (auto *FPT = dyn_cast<DIFixedPointType>(Ty))
+ construct(FPT);
+ else if (auto *BT =...
[truncated]
|
tromey
force-pushed
the
fixed-point-types
branch
from
82b08c6 to
1bbf89a
Compare
|
I had a weirdly-formatted comment in |
pogo59
reviewed
Mar 4, 2025
I don't know, but if there's a spot where I should add docs, let me know & I will. |
tromey
force-pushed
the
fixed-point-types
branch
from
1bbf89a to
4e4507b
Compare
|
Looks like the !DIxxxx are listed in llvm/docs/LangRef.rst (you can see the rendered version at https://llvm.org/docs/LangRef.html#metadata). I thought there was a separate debug-info doc but this is where the metadata descriptions live. |
This adds DWARF generation for fixed-point types. This feature is needed by Ada. Note that a pre-existing GNU extension is used in one case. This has been emitted by GCC for years, and is needed because standard DWARF is otherwise incapable of representing these types.
tromey
force-pushed
the
fixed-point-types
branch
from
4e4507b to
ca2cf87
Compare
|
This version adds some documentation. |
|
Ping. |
1 similar comment
|
Ping. |
adrian-prantl
approved these changes
Mar 27, 2025
Yes. With LLVM 19: |
|
This patch was approved, so could someone please check it in? Thank you. |
SchrodingerZhu
pushed a commit
to SchrodingerZhu/llvm-project
that referenced
this pull request
Mar 31, 2025
This adds DWARF generation for fixed-point types. This feature is needed by Ada. Note that a pre-existing GNU extension is used in one case. This has been emitted by GCC for years, and is needed because standard DWARF is otherwise incapable of representing these types.
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/59/builds/15190 Here is the relevant piece of the build log for the reference |
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/16/builds/16536 Here is the relevant piece of the build log for the reference |
farzonl
added a commit
to farzonl/llvm-project
that referenced
this pull request
Mar 31, 2025
commit: llvm@6894734 added a new `writeDIFixedPointType` function. However DIFixedPointType is not supported in DXIL so we need to add a fail fast case for this to fix the build. this change fixes a build break introduced by llvm#129596
llvm-sync bot
pushed a commit
to arm/arm-toolchain
that referenced
this pull request
Mar 31, 2025
… (#133770) commit: llvm/llvm-project@6894734 added a new `writeDIFixedPointType` function. However, `DIFixedPointType` is not supported in DXIL so we need to add a fail fast case for this to fix the build. this change fixes a build break introduced by llvm/llvm-project#129596
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/56/builds/22282 Here is the relevant piece of the build log for the reference |
|
I don't know what to do about OCaml bindings. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This adds DWARF generation for fixed-point types. This feature is needed by Ada.
Note that a pre-existing GNU extension is used in one case. This has been emitted by GCC for years, and is needed because standard DWARF is otherwise incapable of representing these types.