[llvm] [LLVM-C] Add bindings to `Instruction::getDbgRecordRange()` (PR #107802)
Michal Rostecki via llvm-commits
llvm-commits at lists.llvm.org
Sun Sep 8 20:29:40 PDT 2024
https://github.com/vadorovsky created https://github.com/llvm/llvm-project/pull/107802
Since the migration from `@llvm.dbg.value` intrinsic to `#dbg_value` records, there is no way to retrieve the debug records for an `Instruction` in LLVM-C API.
Previously, with debug info intrinsics, retrieving debug info for an `Instruction` could be done with `LLVMGetNextInstructions`, because the intrinsic call was also an instruction.
However, to be able to retrieve debug info with the current LLVM, where debug records are used, the `getDbgRecordRange()` iterator needs to be exposed.
>From ae324c37a78cc19f1db01f9962100bfb5255e2ad Mon Sep 17 00:00:00 2001
From: Michal Rostecki <vadorovsky at protonmail.com>
Date: Thu, 22 Aug 2024 18:12:00 +0200
Subject: [PATCH] [LLVM-C] Add bindings to `Instruction::getDbgRecordRange()`
Since the migration from `@llvm.dbg.value` intrinsic to `#dbg_value`
records, there is no way to retrieve the debug records for an
`Instruction` in LLVM-C API.
Previously, with debug info intrinsics, retrieving debug info for an
`Instruction` could be done with `LLVMGetNextInstructions`, because the
intrinsic call was also an instruction.
However, to be able to retrieve debug info with the current LLVM, where
debug records are used, the `getDbgRecordRange()` iterator needs to be
exposed.
---
llvm/include/llvm-c/Core.h | 27 ++++++++++++++++++++++++
llvm/lib/IR/Core.cpp | 34 ++++++++++++++++++++++++++++++
llvm/tools/llvm-c-test/debuginfo.c | 31 ++++++++++++++++++++++++---
3 files changed, 89 insertions(+), 3 deletions(-)
diff --git a/llvm/include/llvm-c/Core.h b/llvm/include/llvm-c/Core.h
index a0786efb51fdb2..a14c5832396e7b 100644
--- a/llvm/include/llvm-c/Core.h
+++ b/llvm/include/llvm-c/Core.h
@@ -3682,6 +3682,33 @@ LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst);
*/
LLVMValueRef LLVMIsATerminatorInst(LLVMValueRef Inst);
+/**
+ * Obtain the first debug record in a instruction.
+ *
+ * The returned debug record can be used ad an iterator. You will likely
+ * eventually call into LLVMGetNextDbgRecord() with it.
+ *
+ * @see llvm::Instruction::getDbgRecordRange()
+ */
+LLVMDbgRecordRef LLVMGetFirstDbgRecord(LLVMValueRef Inst);
+
+/**
+ * Obtain the last debug record in a instruction.
+ *
+ * @see llvm::Instruction::getDbgRecordRange()
+ */
+LLVMDbgRecordRef LLVMGetLastDbgRecord(LLVMValueRef Inst);
+
+/**
+ * Advance a debug record iterator.
+ */
+LLVMDbgRecordRef LLVMGetNextDbgRecord(LLVMDbgRecordRef DbgRecord);
+
+/**
+ * Go backwards in a debug record iterator.
+ */
+LLVMDbgRecordRef LLVMGetPreviousDbgRecord(LLVMDbgRecordRef DbgRecord);
+
/**
* @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations
*
diff --git a/llvm/lib/IR/Core.cpp b/llvm/lib/IR/Core.cpp
index 28f603b2c38c8a..32a04c59d4d260 100644
--- a/llvm/lib/IR/Core.cpp
+++ b/llvm/lib/IR/Core.cpp
@@ -12,11 +12,13 @@
//===----------------------------------------------------------------------===//
#include "llvm-c/Core.h"
+#include "llvm-c/Types.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/ConstantRange.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/DebugProgramInstruction.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/DiagnosticPrinter.h"
@@ -2975,6 +2977,38 @@ LLVMValueRef LLVMIsATerminatorInst(LLVMValueRef Inst) {
return (I && I->isTerminator()) ? wrap(I) : nullptr;
}
+LLVMDbgRecordRef LLVMGetFirstDbgRecord(LLVMValueRef Inst) {
+ Instruction *Instr = unwrap<Instruction>(Inst);
+ auto I = Instr->DebugMarker->StoredDbgRecords.begin();
+ if (I == Instr->DebugMarker->StoredDbgRecords.end())
+ return nullptr;
+ return wrap(&*I);
+}
+
+LLVMDbgRecordRef LLVMGetLastDbgRecord(LLVMValueRef Inst) {
+ Instruction *Instr = unwrap<Instruction>(Inst);
+ auto I = Instr->DebugMarker->StoredDbgRecords.rbegin();
+ if (I == Instr->DebugMarker->StoredDbgRecords.rend())
+ return nullptr;
+ return wrap(&*I);
+}
+
+LLVMDbgRecordRef LLVMGetNextDbgRecord(LLVMDbgRecordRef Rec) {
+ DbgRecord *Record = unwrap<DbgRecord>(Rec);
+ simple_ilist<DbgRecord>::iterator I(Record);
+ if (++I == Record->getInstruction()->DebugMarker->StoredDbgRecords.end())
+ return nullptr;
+ return wrap(&*I);
+}
+
+LLVMDbgRecordRef LLVMGetPreviousDbgRecord(LLVMDbgRecordRef Rec) {
+ DbgRecord *Record = unwrap<DbgRecord>(Rec);
+ simple_ilist<DbgRecord>::iterator I(Record);
+ if (I == Record->getInstruction()->DebugMarker->StoredDbgRecords.begin())
+ return nullptr;
+ return wrap(&*--I);
+}
+
unsigned LLVMGetNumArgOperands(LLVMValueRef Instr) {
if (FuncletPadInst *FPI = dyn_cast<FuncletPadInst>(unwrap(Instr))) {
return FPI->arg_size();
diff --git a/llvm/tools/llvm-c-test/debuginfo.c b/llvm/tools/llvm-c-test/debuginfo.c
index 49c90f5b87b83a..f068da1d0a63d9 100644
--- a/llvm/tools/llvm-c-test/debuginfo.c
+++ b/llvm/tools/llvm-c-test/debuginfo.c
@@ -12,6 +12,8 @@
\*===----------------------------------------------------------------------===*/
#include "llvm-c-test.h"
+#include "llvm-c/Core.h"
+#include "llvm-c/Types.h"
#include "llvm-c/DebugInfo.h"
#include <assert.h>
@@ -172,10 +174,20 @@ int llvm_test_dibuilder(void) {
LLVMDIBuilderCreateAutoVariable(DIB, FooLexicalBlock, "d", 1, File,
43, Int64Ty, true, 0, 0);
LLVMValueRef FooVal1 = LLVMConstInt(LLVMInt64Type(), 0, false);
- LLVMMetadataRef FooVarValueExpr =
+ LLVMMetadataRef FooVarValueExpr1 =
LLVMDIBuilderCreateConstantValueExpression(DIB, 0);
- LLVMDIBuilderInsertDbgValueRecordAtEnd(DIB, FooVal1, FooVar1, FooVarValueExpr,
+ LLVMDIBuilderInsertDbgValueRecordAtEnd(DIB, FooVal1, FooVar1, FooVarValueExpr1,
+ FooVarsLocation, FooVarBlock);
+
+ LLVMMetadataRef FooVar2 =
+ LLVMDIBuilderCreateAutoVariable(DIB, FooLexicalBlock, "e", 1, File,
+ 44, Int64Ty, true, 0, 0);
+ LLVMValueRef FooVal2 = LLVMConstInt(LLVMInt64Type(), 1, false);
+ LLVMMetadataRef FooVarValueExpr2 =
+ LLVMDIBuilderCreateConstantValueExpression(DIB, 1);
+
+ LLVMDIBuilderInsertDbgValueRecordAtEnd(DIB, FooVal2, FooVar2, FooVarValueExpr2,
FooVarsLocation, FooVarBlock);
LLVMMetadataRef MacroFile =
@@ -224,14 +236,27 @@ int llvm_test_dibuilder(void) {
LLVMPositionBuilderBeforeInstrAndDbgRecords(Builder, InsertPos);
LLVMValueRef Phi1 = LLVMBuildPhi(Builder, I64, "p1");
LLVMAddIncoming(Phi1, &Zero, &FooEntryBlock, 1);
+
// Do the same again using the other position-setting function.
LLVMPositionBuilderBeforeDbgRecords(Builder, FooVarBlock, InsertPos);
LLVMValueRef Phi2 = LLVMBuildPhi(Builder, I64, "p2");
LLVMAddIncoming(Phi2, &Zero, &FooEntryBlock, 1);
+
// Insert a non-phi before the `ret` but not before the debug records to
// test that works as expected.
LLVMPositionBuilder(Builder, FooVarBlock, Ret);
- LLVMBuildAdd(Builder, Phi1, Phi2, "a");
+ LLVMValueRef Add = LLVMBuildAdd(Builder, Phi1, Phi2, "a");
+
+ // Iterate over debug records in the add instruction. There should be two.
+ LLVMDbgRecordRef AddDbgRecordFirst = LLVMGetFirstDbgRecord(Add);
+ assert(AddDbgRecordFirst != NULL);
+ LLVMDbgRecordRef AddDbgRecordSecond = LLVMGetNextDbgRecord(AddDbgRecordFirst);
+ assert(AddDbgRecordSecond != NULL);
+ LLVMDbgRecordRef AddDbgRecordLast = LLVMGetLastDbgRecord(Add);
+ assert(AddDbgRecordLast != NULL);
+ assert(AddDbgRecordSecond == AddDbgRecordLast);
+ LLVMDbgRecordRef AddDbgRecordOverTheRange = LLVMGetNextDbgRecord(AddDbgRecordSecond);
+ assert(AddDbgRecordOverTheRange == NULL);
char *MStr = LLVMPrintModuleToString(M);
puts(MStr);
More information about the llvm-commits
mailing list