6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-02-21 06:30:16 +00:00
Code Issues Projects Releases Wiki Activity

Add argument variable support to the debug info tutorial

Browse Source 
and rearrange the prologue source location hack to immediately
after it.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223725 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Christopher 2014-12-09 00:28:24 +00:00
parent 9c276c7ab6
commit 772e538fb8
1 changed files with 43 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
docs/tutorial/LangImpl8.rst
View File

@ -372,6 +372,46 @@ store the scope (function) when we create it and use it:
when we start generating the code for each function. when we start generating the code for each function.
also, don't forget to pop the scope back off of your scope stack at the
end of the code generation for the function:
.. code-block:: c++
// Pop off the lexical block for the function since we added it
// unconditionally.
KSDbgInfo.LexicalBlocks.pop_back();
Variables
=========
Now that we have functions, we need to be able to print out the variables
we have in scope. Let's get our function arguments set up so we can get
decent backtraces and see how our functions are being called. It isn't
a lot of code, and we generally handle it when we're creating the
argument allocas in ``PrototypeAST::CreateArgumentAllocas``.
.. code-block:: c++
DIScope *Scope = KSDbgInfo.LexicalBlocks.back();
DIFile Unit = DBuilder->createFile(KSDbgInfo.TheCU.getFilename(),
KSDbgInfo.TheCU.getDirectory());
DIVariable D = DBuilder->createLocalVariable(dwarf::DW_TAG_arg_variable,
*Scope, Args[Idx], Unit, Line,
KSDbgInfo.getDoubleTy(), Idx);
Instruction *Call = DBuilder->insertDeclare(
Alloca, D, DBuilder->createExpression(), Builder.GetInsertBlock());
Call->setDebugLoc(DebugLoc::get(Line, 0, *Scope));
Here we're doing a few things. First, we're grabbing our current scope
for the variable so we can say what range of code our variable is valid
through. Second, we're creating the variable, giving it the scope,
the name, source location, type, and since it's an argument, the argument
index. Third, we create an ``lvm.dbg.declare`` call to indicate at the IR
level that we've got a variable in an alloca (and it gives a starting
location for the variable). Lastly, we set a source location for the
beginning of the scope on the declare.
One interesting thing to note at this point is that various debuggers have One interesting thing to note at this point is that various debuggers have
assumptions based on how code and debug information was generated for them assumptions based on how code and debug information was generated for them
in the past. In this case we need to do a little bit of a hack to avoid in the past. In this case we need to do a little bit of a hack to avoid
@ -393,15 +433,9 @@ body of the function:
KSDbgInfo.emitLocation(Body); KSDbgInfo.emitLocation(Body);
also, don't forget to pop the scope back off of your scope stack at the With this we have enough debug information to set breakpoints in functions,
end of the code generation for the function: print out argument variables, and call functions. Not too bad for just a
few simple lines of code!
.. code-block:: c++
// Pop off the lexical block for the function since we added it
// unconditionally.
KSDbgInfo.LexicalBlocks.pop_back();
Full Code Listing Full Code Listing
================= =================