[LLVMdev] help converting llvm metadata into dwarf tags

[Devang Patel]

woot!

On Sep 7, 2010, at 9:59 AM, Roger Wang wrote:

> hi Devang and thanks for the tips, i finally managed to fit all the pieces together into something that seems to work.
> 
> It's probably not the best (or even correct!) way of doing it but here's a brief overview for reference:
> 
> An instruction in the LLVM IR gets converted into an SDNode in the DAG then later into a MachineInstr.
> I'd already attached my own MDNodes to IR instructions I was interested in. I wanted to propagate that info to the final binary.
> 
> I Added a field to the SelectionDAGBuilder holding the current metadata which I update in SelectionDAGISel::SetDebugLoc()  for every IR instruction.
> Next, in SelectionDAGBuilder::visit() i transfer the current instruction's metadata from the DAGBuilder to the instruction's SDNode.
> 
> In InstrEmitter::EmitNode() I copy the metadata from the SDNode to the MachineInstr. DwarfDebug::endModule() creates my user-defined DIE (after defining my own DW_TAG and DW_AT IDs in Dwarf.h) and adds it to the ModuleCU (for simplicity I'm adding my DIEs to the module's debug_info section)
> 
> I Added a few lines to Dwarf.cpp for emitting the correct name for my new DW_TAG and AT (useful when looking at commented assembly)
> 
> Finally, in AsmPrinter::processDebugLoc() I grab the metadata from the MachineInstr and pass it to the DwarfWriter to add it to its DwarfDebug member. When the assembly is emitted, the debug_info section contains my new dwarf DIE which I've managed to retrieve from the binary with a dwarf consumer.
> 
> cheers,
> rw.
> 
> 
> 
> On 24 August 2010 02:46, Devang Patel <devang.patel at gmail.com> wrote:
> Hi Roger,
> 
> On Mon, Aug 23, 2010 at 4:01 PM, Roger Wang <innit42 at gmail.com> wrote:
> Dear all,
> 
> I'd like to find the memory location of certain instructions in a compiled/linked binary. During the IR phase, I tag instructions I'm interested in with LLVM'-2.7's new metadata (MDNodes with an identifiable ID). I'd now like to propagate that data to the assembly via a custom DWARF tag I attach to each X86 instruction created from a tagged IR instruction. This will then find its way at assembly time into the binary from where I retrieve it (by locating my custom tags with a DWARF consumer and dumping the addresses of the instruction they're attached to).
> 
> Does this sound reasonable?
> 
> I've completed the first part, attaching the MDNodes to IR instructions but I'm a bit overwhelmed by all the backend stuff.
> How can I identify which IR instruction an X86 instruction came from (with a view to attaching an identifying DW_TAG to it)?
> 
> 1) LLVM IR instructions are converted into  MachineInstr during instruction selection time. At this point you need to transfer your custom metadata to MachineInstr. See how DebugLoc is transfered (in CodeGen/SelectionDAG directory).
> 
> 2) At AsmPrint time, while emitting your assembly instructions you have access to coresponding MachineInstr and any custom metadata attached with it.
> 
> I've found the tag definitions in include/llvm/Support/Dwarf.h and added my own.
> lib/CodeGen/AsmPrinter/DwarfDebug.cpp seems to be the only place that emits dwarf data into the assembly stream.
> 
> See have DwarfDebug.cpp handles DebugLoc attached with each instruction (::beginScope() and ::endScope()).
>  
> It also seems to create a DebugInfoFinder which accesses the IR instructions.
> 
> This path will allow you to browse entire function and collect info which you can use later on. 
> 
> -
> Devang
> 
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20100907/a2bfa808/attachment.html>