52f792329be5db8e38961350589e97e8f2823acd |
|
12-Jul-2013 |
Greg Clayton <gclayton@apple.com> |
Huge change to clean up types. A long time ago we start with clang types that were created by the symbol files and there were many functions in lldb_private::ClangASTContext that helped. Later we create ClangASTType which contains a clang::ASTContext and an opauque QualType, but we didn't switch over to fully using it. There were a lot of places where we would pass around a raw clang_type_t and also pass along a clang::ASTContext separately. This left room for error. This checkin change all type code over to use ClangASTType everywhere and I cleaned up the interfaces quite a bit. Any code that was in ClangASTContext that was type related, was moved over into ClangASTType. All code that used these types was switched over to use all of the new goodness. git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@186130 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
d4f95f3c9462a977f8c15c5062d30bf62cd49110 |
|
29-Mar-2013 |
Greg Clayton <gclayton@apple.com> |
<rdar://problem/11730263> PC relative loads are missing disassembly comments when disassembled in a live process. This issue was because some sections, like __TEXT and __DATA in libobjc.A.dylib, were being moved when they were put into the dyld shared cache. This could also affect any other system that slides sections individually. The solution is to keep track of wether the bytes we will disassemble are from an executable file (file address), or from a live process (load address). We now do the right thing based off of this input in all cases. git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@178315 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
7d4083837c5a258375fdc185d464b4ed15759a4b |
|
02-Mar-2013 |
Jim Ingham <jingham@apple.com> |
Convert from the C-based LLVM Disassembler shim to the full MC Disassembler API's. Calculate "can branch" using the MC API's rather than our hand-rolled regex'es. As extra credit, allow setting the disassembly flavor for x86 based architectures to intel or att. <rdar://problem/11319574> <rdar://problem/9329275> git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@176392 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
d891f9b872103235cfd2ed452c6f14a4394d9b3a |
|
05-Dec-2012 |
Daniel Malea <daniel.malea@intel.com> |
Fix Linux build warnings due to redefinition of macros: - add new header lldb-python.h to be included before other system headers - short term fix (eventually python dependencies must be cleaned up) Patch by Matt Kopec! git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@169341 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
6f01c93497df194b6f2194630a81e87d806ce0e0 |
|
12-Oct-2012 |
Jim Ingham <jingham@apple.com> |
Bunch of cleanups for warnings found by the llvm static analyzer. git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@165808 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
49ce8969d3154e1560106cfe530444c09410f217 |
|
29-Aug-2012 |
Greg Clayton <gclayton@apple.com> |
<rdar://problem/11757916> Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes: - Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file". - modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly - Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was. - modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile() Cleaned up header includes a bit as well. git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@162860 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
4f28c31e4b652a842ce6138b70ded44ffb3e8c48 |
|
01-Aug-2012 |
Sean Callanan <scallanan@apple.com> |
Instructions generated by a disassembler can now keep a shared pointer to their disassembler. This is important for the LLVM-C disassembler because it needs to lock its parent in order to disassemble itself. This means that every interface that returned a Disassembler* needs to return a DisassemblerSP, so that the instructions and any external owners share the same reference count on the object. I changed all clients to use this shared pointer, which also plugged a few leaks. <rdar://problem/12002822> git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@161123 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
0fef968c843be422d6facc2e8d54d8471eee88ed |
|
10-May-2012 |
Greg Clayton <gclayton@apple.com> |
<rdar://problem/11330621> Fixed the DisassemblerLLVMC disassembler to parse more efficiently instead of parsing opcodes over and over. The InstructionLLVMC class now only reads the opcode in the InstructionLLVMC::Decode function. This can be done very efficiently for ARM and architectures that have fixed opcode sizes. For x64 it still calls the disassembler to get the byte size. Moved the lldb_private::Instruction::Dump(...) function up into the lldb_private::Instruction class and it now uses the function that gets the mnemonic, operandes and comments so that all disassembly is using the same code. Added StreamString::FillLastLineToColumn() to allow filling a line up to a column with a character (which is used by the lldb_private::Instruction::Dump(...) function). Modified the Opcode::GetData() fucntion to "do the right thing" for thumb instructions. git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@156532 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
3508c387c3f0c9ecc439d98048fd7694d41bab1b |
|
24-Feb-2012 |
Greg Clayton <gclayton@apple.com> |
<rdar://problem/10103468> I started work on being able to add symbol files after a debug session had started with a new "target symfile add" command and quickly ran into problems with stale Address objects in breakpoint locations that had lldb_private::Section pointers into modules that had been removed or replaced. This also let to grabbing stale modules from those sections. So I needed to thread harded the Address, Section and related objects. To do this I modified the ModuleChild class to now require a ModuleSP on initialization so that a weak reference can created. I also changed all places that were handing out "Section *" to have them hand out SectionSP. All ObjectFile, SymbolFile and SymbolVendors were inheriting from ModuleChild so all of the find plug-in, static creation function and constructors now require ModuleSP references instead of Module *. Address objects now have weak references to their sections which can safely go stale when a module gets destructed. This checkin doesn't complete the "target symfile add" command, but it does get us a lot clioser to being able to do such things without a high risk of crashing or memory corruption. git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@151336 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
f4124deeb9532044a38c0774ced872f2709347da |
|
21-Feb-2012 |
Greg Clayton <gclayton@apple.com> |
Thread hardening part 3. Now lldb_private::Thread objects have std::weak_ptr objects for the backlink to the lldb_private::Process. The issues we were running into before was someone was holding onto a shared pointer to a lldb_private::Thread for too long, and the lldb_private::Process parent object would get destroyed and the lldb_private::Thread had a "Process &m_process" member which would just treat whatever memory that used to be a Process as a valid Process. This was mostly happening for lldb_private::StackFrame objects that had a member like "Thread &m_thread". So this completes the internal strong/weak changes. Documented the ExecutionContext and ExecutionContextRef classes so that our LLDB developers can understand when and where to use ExecutionContext and ExecutionContextRef objects. git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@151009 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
c51ffbf896e398ada5f7e89b2fa5aec6f2224f09 |
|
12-Aug-2011 |
Greg Clayton <gclayton@apple.com> |
We were leaking a stack frame in StackFrameList in Thread.cpp which could cause extra shared pointer references to one or more modules to be leaked. This would cause many object files to stay around the life of LLDB, so after a recompile and rexecution, we would keep adding more and more memory. After fixing the leak, we found many cases where leaked stack frames were still being used and causing crashes in the test suite. These are now all resolved. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@137516 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
5beb99d65c72cd4a4f7529c4ff8cc04a1a40769d |
|
11-Aug-2011 |
Greg Clayton <gclayton@apple.com> |
Added the ability to remove orphaned module shared pointers from a ModuleList. This is helping us track down some extra references to ModuleSP objects that are causing things to get kept around for too long. Added a module pointer accessor to target and change a lot of code to use it where it would be more efficient. "taret delete" can now specify "--clean=1" which will cleanup the global module list for any orphaned module in the shared module cache which can save memory and also help track down module reference leaks like we have now. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@137294 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
b586767bf7ec45778ef478661fd24ea117ebc321 |
|
22-Jun-2011 |
Jim Ingham <jingham@apple.com> |
Trivial fix - insert a space between the frame name and the instruction output. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@133647 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
41ae8125cb49ec90b2a249f4f8d903d24cacea1c |
|
22-Jun-2011 |
Jim Ingham <jingham@apple.com> |
Reverting switch to the AsyncOutputStream for the Thread Trace Logger. This change caused the logger to crash. Presumably we're printing at a time the debugger isn't ready to print. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@133629 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
2b5e4e6bc442fb77e7fe96c459f9ca38d4970ed0 |
|
15-Jun-2011 |
Caroline Tice <ctice@apple.com> |
Replace direct uses of the Debugger's output stream with uses of the asynchronous stream. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@133076 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
b9e8f6e7a374d9313f89193e90ae41ef91712e5b |
|
18-May-2011 |
Greg Clayton <gclayton@apple.com> |
Added a way to resolve an load address from a target: bool Address::SetLoadAddress (lldb::addr_t load_addr, Target *target); Added an == and != operator to RegisterValue. Modified the ThreadPlanTracer to use RegisterValue objects to store the register values when single stepping. Also modified the output to be a bit less wide. Fixed the ABIMacOSX_arm to not overwrite stuff on the stack. Also made the trivial function call be able to set the ARM/Thumbness of the target correctly, and also sets the return value ARM/Thumbness. Fixed the encoding on the arm s0-s31 and d16 - d31 registers when the default register set from a standard GDB server register sets. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@131517 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
75906e4ec98af3717e415727a8d663a4e246bb4f |
|
11-May-2011 |
Greg Clayton <gclayton@apple.com> |
Moved all code from ArchDefaultUnwindPlan and ArchVolatileRegs into their respective ABI plugins as they were plug-ins that supplied ABI specfic info. Also hookep up the UnwindAssemblyInstEmulation so that it can generate the unwind plans for ARM. Changed the way ABI plug-ins are handed out when you get an instance from the plug-in manager. They used to return pointers that would be mananged individually by each client that requested them, but now they are handed out as shared pointers since there is no state in the ABI objects, they can be shared. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@131193 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
dbeb3e1e038a75f00fd565203839020e1d00a7c6 |
|
11-Apr-2011 |
Stephen Wilson <wilsons@start.ca> |
Order of initialization lists. This patch fixes all of the warnings due to unordered initialization lists. Patch by Marco Minutoli. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@129290 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
889fbd0581c24523642e0a04d659cc8f3dcdb4ed |
|
26-Mar-2011 |
Greg Clayton <gclayton@apple.com> |
Added the ability to get the min and max instruction byte size for an architecture into ArchSpec: uint32_t ArchSpec::GetMinimumOpcodeByteSize() const; uint32_t ArchSpec::GetMaximumOpcodeByteSize() const; Added an AddressClass to the Instruction class in Disassembler.h. This allows decoded instructions to know know if they are code, code with alternate ISA (thumb), or even data which can be mixed into code. The instruction does have an address, but it is a good idea to cache this value so we don't have to look it up more than once. Fixed an issue in Opcode::SetOpcodeBytes() where the length wasn't getting set. Changed: bool SymbolContextList::AppendIfUnique (const SymbolContext& sc); To: bool SymbolContextList::AppendIfUnique (const SymbolContext& sc, bool merge_symbol_into_function); This function was typically being used when looking up functions and symbols. Now if you lookup a function, then find the symbol, they can be merged into the same symbol context and not cause multiple symbol contexts to appear in a symbol context list that describes the same function. Fixed the SymbolContext not equal operator which was causing mixed mode disassembly to not work ("disassembler --mixed --name main"). Modified the disassembler classes to know about the fact we know, for a given architecture, what the min and max opcode byte sizes are. The InstructionList class was modified to return the max opcode byte size for all of the instructions in its list. These two fixes means when disassemble a list of instructions and dump them and show the opcode bytes, we can format the output more intelligently when showing opcode bytes. This affects any architectures that have varying opcode byte sizes (x86_64 and i386). Knowing the max opcode byte size also helps us to be able to disassemble N instructions without having to re-read data if we didn't read enough bytes. Added the ability to set the architecture for the disassemble command. This means you can easily cross disassemble data for any supported architecture. I also added the ability to specify "thumb" as an architecture so that we can force disassembly into thumb mode when needed. In GDB this was done using a hack of specifying an odd address when disassembling. I don't want to repeat this hack in LLDB, so the auto detection between ARM and thumb is failing, just specify thumb when disassembling: (lldb) disassemble --arch thumb --name main You can also have data in say an x86_64 file executable and disassemble data as any other supported architecture: % lldb a.out Current executable set to 'a.out' (x86_64). (lldb) b main (lldb) run (lldb) disassemble --arch thumb --count 2 --start-address 0x0000000100001080 --bytes 0x100001080: 0xb580 push {r7, lr} 0x100001082: 0xaf00 add r7, sp, #0 Fixed Target::ReadMemory(...) to be able to deal with Address argument object that isn't section offset. When an address object was supplied that was out on the heap or stack, target read memory would fail. Disassembly uses Target::ReadMemory(...), and the example above where we disassembler thumb opcodes in an x86 binary was failing do to this bug. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@128347 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
149731c0b267e5b6cd7192cbfac0c7f457ae5cfc |
|
25-Mar-2011 |
Greg Clayton <gclayton@apple.com> |
Cleaned up the Disassembler code a bit more. You can now request a disassembler plugin by name on the command line for when there is more than one disassembler plugin. Taught the Opcode class to dump itself so that "disassembler -b" will dump the bytes correctly for each opcode type. Modified all places that were passing the opcode bytes buffer in so that the bytes could be displayed to just pass in a bool that indicates if we should dump the opcode bytes since the opcode now lives inside llvm_private::Instruction. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@128290 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
aa3e3e1f0f3be95c79f902c5331e11878f66b365 |
|
22-Mar-2011 |
Jim Ingham <jingham@apple.com> |
Add the ability to disassemble "n" instructions from the current PC, or the first "n" instructions in a function. Also added a "-p" flag that disassembles from the current pc. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@128063 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
ddff7cca4b3d2507706ed9011e6f0a503b984195 |
|
04-Feb-2011 |
Greg Clayton <gclayton@apple.com> |
Remove bzero use and replace with memset (patch from Kirk Beitz). git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@124897 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
b01000fd063629facd45044f137446fb748ee179 |
|
17-Jan-2011 |
Greg Clayton <gclayton@apple.com> |
A few of the issue I have been trying to track down and fix have been due to the way LLDB lazily gets complete definitions for types within the debug info. When we run across a class/struct/union definition in the DWARF, we will only parse the full definition if we need to. This works fine for top level types that are assigned directly to variables and arguments, but when we have a variable with a class, lets say "A" for this example, that has a member: "B *m_b". Initially we don't need to hunt down a definition for this class unless we are ever asked to do something with it ("expr m_b->getDecl()" for example). With my previous approach to lazy type completion, we would be able to take a "A *a" and get a complete type for it, but we wouldn't be able to then do an "a->m_b->getDecl()" unless we always expanded all types within a class prior to handing out the type. Expanding everything is very costly and it would be great if there were a better way. A few months ago I worked with the llvm/clang folks to have the ExternalASTSource class be able to complete classes if there weren't completed yet: class ExternalASTSource { .... virtual void CompleteType (clang::TagDecl *Tag); virtual void CompleteType (clang::ObjCInterfaceDecl *Class); }; This was great, because we can now have the class that is producing the AST (SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources and the object that creates the forward declaration types can now also complete them anywhere within the clang type system. This patch makes a few major changes: - lldb_private::Module classes now own the AST context. Previously the TypeList objects did. - The DWARF parsers now sign up as an external AST sources so they can complete types. - All of the pure clang type system wrapper code we have in LLDB (ClangASTContext, ClangASTType, and more) can now be iterating through children of any type, and if a class/union/struct type (clang::RecordType or ObjC interface) is found that is incomplete, we can ask the AST to get the definition. - The SymbolFileDWARFDebugMap class now will create and use a single AST that all child SymbolFileDWARF classes will share (much like what happens when we have a complete linked DWARF for an executable). We will need to modify some of the ClangUserExpression code to take more advantage of this completion ability in the near future. Meanwhile we should be better off now that we can be accessing any children of variables through pointers and always be able to resolve the clang type if needed. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@123613 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
08d7d3ae16110aa68ed40c161eac8571aeb94cd9 |
|
06-Jan-2011 |
Greg Clayton <gclayton@apple.com> |
Fixed issues with RegisterContext classes and the subclasses. There was an issue with the way the UnwindLLDB was handing out RegisterContexts: it was making shared pointers to register contexts and then handing out just the pointers (which would get put into shared pointers in the thread and stack frame classes) and cause double free issues. MallocScribble helped to find these issues after I did some other cleanup. To help avoid any RegisterContext issue in the future, all code that deals with them now returns shared pointers to the register contexts so we don't end up with multiple deletions. Also now that the RegisterContext class doesn't require a stack frame, we patched a memory leak where a StackFrame object was being created and leaked. Made the RegisterContext class not have a pointer to a StackFrame object as one register context class can be used for N inlined stack frames so there is not a 1 - 1 mapping. Updates the ExecutionContextScope part of the RegisterContext class to never return a stack frame to indicate this when it is asked to recreate the execution context. Now register contexts point to the concrete frame using a concrete frame index. Concrete frames are all of the frames that are actually formed on the stack of a thread. These concrete frames can be turned into one or more user visible frames due to inlining. Each inlined stack frame has the exact same register context (shared via shared pointers) as any parent inlined stack frames all the way up to the concrete frame itself. So now the stack frames and the register contexts should behave much better. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@122976 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
c783660b81ff6ffe626354dc3af48d98cc17734d |
|
17-Nov-2010 |
Jim Ingham <jingham@apple.com> |
Add a missing newline to the ThreadPlanAssemblyTracer output. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@119553 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
ae7862a7fa70080e7450174b05544e7673fefb9d |
|
17-Nov-2010 |
Jim Ingham <jingham@apple.com> |
Add a ThreadPlanAssemblyTracer that takes just a thread (since that's how we call it from ThreadPlanBase...) git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@119549 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
6916e358c9725b75ed91f31236c147f26c9af10e |
|
13-Nov-2010 |
Greg Clayton <gclayton@apple.com> |
Modified the lldb_private::Type clang type resolving code to handle three cases when getting the clang type: - need only a forward declaration - need a clang type that can be used for layout (members and args/return types) - need a full clang type This allows us to partially parse the clang types and be as lazy as possible. The first case is when we just need to declare a type and we will complete it later. The forward declaration happens only for class/union/structs and enums. The layout type allows us to resolve the full clang type _except_ if we have any modifiers on a pointer or reference (both R and L value). In this case when we are adding members or function args or return types, we only need to know how the type will be laid out and we can defer completing the pointee type until we later need it. The last type means we need a full definition for the clang type. Did some renaming of some enumerations to get rid of the old "DC" prefix (which stands for DebugCore which is no longer around). Modified the clang namespace support to be almost ready to be fed to the expression parser. I made a new ClangNamespaceDecl class that can carry around the AST and the namespace decl so we can copy it into the expression AST. I modified the symbol vendor and symbol file plug-ins to use this new class. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@118976 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
5b0228a06dedf7d450308a443c255f2d28c247f3 |
|
12-Nov-2010 |
Sean Callanan <scallanan@apple.com> |
Added a thread plan tracer that prints lines of assembly as well as registers that changed. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@118879 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|
745ac7a5826fe7c392007941a4046bfb1a8dff81 |
|
11-Nov-2010 |
Jim Ingham <jingham@apple.com> |
Add ThreadPlanTracer class to allow instruction step tracing of execution. Also changed eSetVarTypeBool to eSetVarTypeBoolean to make it consistent with eArgTypeBoolean. git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@118824 91177308-0d34-0410-b5e6-96231b3b80d8
/external/lldb/source/Target/ThreadPlanTracer.cpp
|