New lldb python module for adding diagnostic breakpoints

[hintonda]

Summary

This module adds a breakpoint for calls to DiagnosticsEngine::Report which will fire each time a diagnostic, e.g., error, warning, etc., is hit, and add breakpoints for all locations where that diagnostic ID is used.

It is intended for use by developers and relies on diagtool being in the same directory of the executable begin debugged, e.g.:

$ lldb bin/clang-6.0
(lldb) target create "bin/clang-6.0"
Current executable set to 'bin/clang-6.0' (x86_64).
(lldb) command script import ../../llvm/tools/clang/utils/clangdiag.py
The "clangdiag" command has been installed, type "help clangdiag" or "clangdiag --help" for detailed help.
(lldb) clangdiag enable
(lldb) run <....>

Breakpoints get added as DiagnosticsEngine::Report is seen, so you will need to run it twice.

[rjmccall]

Since this is fundamentally an LLDB script, I've tagged a couple of LLDB people to review it.

Jason, Sean: the idea here is to make it easier for clang developers to debug unexpected diagnostics by automatically setting breakpoints on the places that originate the observed diagnostics.

[hintonda]

• Use temp files instead of temp dir.

[hintonda]

ping...

[hintonda]

ping...

[zturner]

One possible reason for why this never got any traction is that lldb-commits wasn't added as a subscriber. While it's true that the tagged people should have chimed in, having the whole commits list will get some more visibility. I never saw this come to my inbox.

I think this would be most suitable in the lldb/examples folder.

I can't really review this thoroughly, because it relies on a bash script, and I use Windows where we bash isn't really a thing. My bash is rusty, but it looks like you're embedding a python script in the bash script? It might be good if this were just an lldb script command. Take a look at command script add in LLDB, and in the examples folder for some examples of existing commands that work this way. The nice thing about doing it this way is that you could just be inside LLDB and write (lldb) break-diag -Wcovered-switch, for example, which would be a much tighter integration with the debugger.

[hintonda]

In D36347#901885, @zturner wrote:

One possible reason for why this never got any traction is that lldb-commits wasn't added as a subscriber. While it's true that the tagged people should have chimed in, having the whole commits list will get some more visibility. I never saw this come to my inbox.

I think this would be most suitable in the lldb/examples folder.

I can't really review this thoroughly, because it relies on a bash script, and I use Windows where we bash isn't really a thing. My bash is rusty, but it looks like you're embedding a python script in the bash script? It might be good if this were just an lldb script command. Take a look at command script add in LLDB, and in the examples folder for some examples of existing commands that work this way. The nice thing about doing it this way is that you could just be inside LLDB and write (lldb) break-diag -Wcovered-switch, for example, which would be a much tighter integration with the debugger.

Thanks for taking a look.

I mainly work on *nix systems, hence the initial shell script, but if there's an interest, I'll be happy to convert it to a single python script as you suggest, and resubmit it as a patch to lldb.

Thanks again...

[clayborg]

Please do convert to python. Just know that you can use "lldb -P" to get the python path that is needed in order to do "import lldb" in the python script. So you can try doing a "import lldb", and if that fails, catch the exception, run "lldb -P", add that path to the python path:

try:
    # Just try for LLDB in case the lldb module is already in the python search
    # paths
    import lldb
except ImportError:
    # We failed to import lldb automatically. Run lldb with the -P option so
    # it tells us the python path we should use.
    lldb_py_dirs = list()
    (status, output) = commands.getstatusoutput("lldb -P")
    dir = os.path.realpath(output)
    if status == 0 and os.path.isdir(dir):
        lldb_py_dirs.append(dir)
    success = False
    for lldb_py_dir in lldb_py_dirs:
        if os.path.exists(lldb_py_dir):
            if not (sys.path.__contains__(lldb_py_dir)):
                sys.path.append(lldb_py_dir)
                try:
                    import lldb
                except ImportError:
                    pass
                else:
                    success = True
                    break
    if not success:
        print("error: couldn't locate the 'lldb' module, please set "
              "PYTHONPATH correctly")
        sys.exit(1)

[zturner]

In D36347#902157, @clayborg wrote:

Please do convert to python. Just know that you can use "lldb -P" to get the python path that is needed in order to do "import lldb" in the python script. So you can try doing a "import lldb", and if that fails, catch the exception, run "lldb -P", add that path to the python path:

try:
    # Just try for LLDB in case the lldb module is already in the python search
    # paths
    import lldb
except ImportError:
    # We failed to import lldb automatically. Run lldb with the -P option so
    # it tells us the python path we should use.
    lldb_py_dirs = list()
    (status, output) = commands.getstatusoutput("lldb -P")
    dir = os.path.realpath(output)
    if status == 0 and os.path.isdir(dir):
        lldb_py_dirs.append(dir)
    success = False
    for lldb_py_dir in lldb_py_dirs:
        if os.path.exists(lldb_py_dir):
            if not (sys.path.__contains__(lldb_py_dir)):
                sys.path.append(lldb_py_dir)
                try:
                    import lldb
                except ImportError:
                    pass
                else:
                    success = True
                    break
    if not success:
        print("error: couldn't locate the 'lldb' module, please set "
              "PYTHONPATH correctly")
        sys.exit(1)

Is any of this really necessary? If you load this script via command script add (which is definitely better than having this be a post-processing script that someone has to manually run) then it is guaranteed to be in the path. Just import it, like the other examples in lldb/examples/python/jump.py for an example. The idea is to have it do the indexing when the command is loaded and save it to a global, and then each time it runs it uses the global index. This way it's invisible to the user, you just run bcd -Wcovered-switch or something without worrying about it.

[clayborg]

If you want to run the script from the command line, then it is necessary. If it is run from within LLDB it will just work. I like to have my LLDB python scripts work both ways.

This might be better implemented as a new command that gets installed and can be used within LLDB. See:

http://llvm.org/svn/llvm-project/lldb/trunk/examples/python/cmdtemplate.py

[jingham]

I can't see anything wrong with the SB API use here. I don't feel qualified to comment on the most effective workflow for an analysis I've never had to do, however.

[jasonmolenda]

Sorry for missing this back in August.

I think it'd be clearer to import your python once in the startup, like

-o "script import $module" \

Multiple imports are a no-op IIUC so it's harmless to re-import the module every time the breakpoint is hit (I'm guessing it's only hit once, for that matter), but I think it's clearer to have this on its own line.

For what it's worth, if you use breakpoint command add -F python-function, your function is passed in the frame as well as the SBBreakpointLocation. See 'help breakpoint add' for more information about this; I used this in a breakpoint python command I wrote a while back,

def handle_pthread_create_return(frame, bp_loc, dict):

global pthreads_being_created

thread_index_id = frame.GetThread().GetIndexID()

[...]

it might be a good idea to name the breakpoint you're adding and then you can delete it explicitly, in case the user is doing something unexpected with breakpoints. e.g.

% ~/k/svn/lldb/build/Debug/lldb /tmp/a.out
(lldb) target create "/tmp/a.out"
Current executable set to '/tmp/a.out' (x86_64).
(lldb) br s -n main -N worker
Breakpoint 1: where = a.out`main, address = 0x0000000100000ec0
(lldb) br del worker
1 breakpoints deleted; 0 breakpoint locations disabled.
(lldb) br li
No breakpoints currently set.
(lldb)

[hintonda]

Thanks for all the feedback. I'll report back once I've addressed all your suggestions.

Thanks again...

[hintonda]

Reimplement at a python module.

[clayborg]

Looks good. A little bit of cleanup. Let me know what you think of the comments.

utils/clangdiag.py

17 ↗

(On Diff #120308)

I would rather just do:

import subprocess

Then later use:

subprocess.check_output(...)

It makes the code easier to read.

20 ↗

(On Diff #120308)

Remove? See inlined comment for line 92

21 ↗

(On Diff #120308)

I would avoid making this a global. It will keep the target alive since it has a strong reference count to the underlying lldb_private::Target.

52 ↗

(On Diff #120308)

Get the target from the frame instead of grabbing it from a global:

target = frame.thread.process.target

or without the shortcuts:

target = frame.GetThread().GetProcess().GetTarget()

66 ↗

(On Diff #120308)

Always grab the target and don't store it in a global. so just remove this line

75–78 ↗

(On Diff #120308)

Allow "diagtool" to be set from an option maybe? This would require the options to be passed into this function as an argument. If it doesn't get set, then modify the options to contain this default value? Then this error message can just complain about the actual path:

print('diagtool "%s" doesn't exist' % diagtool)

80 ↗

(On Diff #120308)

Add name to breakpoint? See inlined comment at line 92

87 ↗

(On Diff #120308)

remove and use:

target = debugger.GetSelectedTarget()

91–92 ↗

(On Diff #120308)

Another way to do this would be to give the breakpoints you create using "target.BreakpointCreateXXX" to have a name when you create them:

bp = target.BreakpointCreateByName('DiagnosticsEngine::Report')
bp.AddName("llvm::Diagnostic")

Then here you can iterate over all breakpoints in the target:

for bp in target.breakpoint_iter():
  if bp.MatchesName("llvm::Diagnostic"):
    target.BreakpointDelete(bp.GetID())

Then you don't need a global list?

[hintonda]

Thanks for the quick feedback. I'll make all you suggested changes, but need to think a little more about diagtool.

utils/clangdiag.py

75–78 ↗

(On Diff #120308)

The problem is that diagtool contains a map of DiagID -> DiagEnums, and must be in sync. I wasn't sure how else to enforce the version you were using was built at the same time as the code you're trying to debug.

I can add the option, but then you might get bogus output.

[jingham]

Use the form of the command that gets an SBExecutionContext, then you can avoid having to cache the target at all.

utils/clangdiag.py

98–100 ↗

(On Diff #120308)

If you use the form of the command function that takes an execution context:

def command_function(debugger, command, exe_ctx, result, internal_dict):

then you can grab the target from there when the command gets invoked and pass it to your enable & disable funcs. That way you won't have to rely on GetSelectedTarget. That's important, for instance, if you were running a debug session with two targets and you wanted to invoke your command in a breakpoint command of a breakpoint in target A. There's no guarantee when target A hits the breakpoint that A is the currently selected target (it won't get selected till it actually decides to stop.) But when the breakpoint runs its command, it sets the right target, & thread in the execution context that gets passed in.

[jingham]

Yes definitely use names for your breakpoints. It makes them easier to handle. Note starting a month or two ago you can set names to not get deleted except by an explicit gesture. That hasn't shown up in releases yet, but once you can rely on its being there, you can set the names to not get auto-deleted or disabled, and then if somebody does:

(lldb) break disable

not thinking they are affecting your utility, you won't get messed up by this.

utils/clangdiag.py

87 ↗

(On Diff #120308)

See my comment. Don't use selected targets, use the command form that takes an SBExecutionContext. That's been around for more than a couple of years now, so it's pretty safe to use.

91–92 ↗

(On Diff #120308)

If you name them you can just do:

target.BreakpointDeleteByName("llvm::Diagnostic")

That's even simpler.

[clayborg]

utils/clangdiag.py

62 ↗

(On Diff #120308)

Pass exe_ctx or target into this instead of the debugger (see Jim's comment on execution contexts below.

78 ↗

(On Diff #120308)

No need. just a suggestion. Is this information available in the main executable as any kind of debug info? If so you can read it from there. If it is always in a stand alone separate file, then what you have is ok.

87 ↗

(On Diff #120308)

Just pass the target or exe_ctx into this function then instead of "debugger".

92 ↗

(On Diff #120308)

nice!

100 ↗

(On Diff #120308)

Great idea. Forgot about the execution context variant. The "exe_ctx" is a lldb.SBExecutionContext object. You get your target using:

target = exe_ctx.GetTarget()

[jingham]

Note, BTW, Enrico also added a form of the command add that allows you to use a Python class to wrap the callable. That was in early 2015 so it's probably safe to use as well by now. That's even more convenient, and obviates the need for globals at all. One instance of the class is made per debugger as the command gets loaded, so its ivars live for the life of the command - spanning executions.

There's an example of it here:

http://llvm.org/svn/llvm-project/lldb/trunk/examples/python/disassembly_mode.py

and it is mentioned in the Python Ref.

You don't by any means have to use this form, but if you are having fun playing around with this stuff, it makes it much more pleasant to write commands.

utils/clangdiag.py

100 ↗

(On Diff #120308)

Yeah, if I could think of a friendly way to do it, I would outlaw the older form. That was an oversight, and makes commands that aren't guaranteed to behave correctly in breakpoint callbacks.

I'll go make the docs a little stronger now that the exe_ctx form has been there long enough that it's generally safe to use.

[hintonda]

• Addressed comments.

[hintonda]

utils/clangdiag.py

83 ↗

(On Diff #120340)

Can't use iterator because it gets invalidated and not all breakpoints get removed. Also, target.BreakpointDeleteByName doesn't seem to exist, so iterated over SBBreakpointList instead.

[jingham]

Ack, my bad. I should remember not to rely on my memory...

I thought at one point I was going to do it that way, then got annoyed I'd have to have "BreakpointDisableByName" etc... So apparently I made:

SBTarget.FindBreakpointByName

that takes a name & an SBBreakpointList, and the list gets filled with the breakpoints that match that name.

[hintonda]

• Add diagtool option used to set arbitrary diagtool path.

[clayborg]

Very close. Thanks for making the changes. Just a few nits.

utils/clangdiag.py

66 ↗

(On Diff #120360)

Is there only ever one of these? If so this is good.

117 ↗

(On Diff #120360)

should probably verify that this 'diagtool' with:

elif args.subcommands == 'diagtool':

and add an else that creates an error:

else:
    result.SetError("invalid subcommand '%s'" % (args.subcommands))

[hintonda]

Thanks for the feedback (addressed below).

btw, where should this module go?

Since it's intended for clang, and clang based tool, developers, I put it in clang/utils, but Zackery suggested lldb/examples/python might be a better place. Please let me know if anyone has a preference.

utils/clangdiag.py

66 ↗

(On Diff #120360)

Currently, DiagnosticsEngine::Report only has two signatures, and both contain an unsigned DiagID parameter, so this is just a sanity check to make sure we are in the right place.

117 ↗

(On Diff #120360)

This is already handled by argparser, which will raise an exception if the first parameter isn't one of (enable, disable, daigtool). That's the benefit of using subparsers. So, by the time you get to this point, it must be "diagtool".

However, I think I should probably verify the path past actually exists. Plus, I think I could add a better exception to alert the user how to fix the problem if diagtool couldn't be found in the callback. Suggestions welcome.

[zturner]

Do I understand correctly that this will insert breakpoints on *all* clang diagnostics? That's not necessarily bad, but I was under the impression originally that it would let you pick the diagnostics you wanted to insert breakpoints on.

Also, What is the workflow for using the "clangdiag diagtool" subcommand? Would you have to do two steps, clangdiag enable and then clangdiag diagtool? If so, maybe it could just be clangdiag enable --diagtool=<path>

[clayborg]

utils/clangdiag.py

117 ↗

(On Diff #120360)

nice, I didn't realized that argparser would protect against that. Checking the file exists would be a good idea.

[hintonda]

• Enhance diagtool option to check, reset, print out current value.

[clayborg]

Looks good.

[hintonda]

In D36347#908186, @zturner wrote:

Do I understand correctly that this will insert breakpoints on *all* clang diagnostics? That's not necessarily bad, but I was under the impression originally that it would let you pick the diagnostics you wanted to insert breakpoints on.

clangdiag enable sets a breakpoint in DiagnosticsEngine::Report and adds a callback. The callback passed the value of DiagID to diagtool to get the enum spelling of the DiagID, e.g., err_undeclared_var_use, then calls BreakpointCreateBySourceRegex with that string and and empty FileSpec to set breakpoints in every location that string is seen -- specifically, we use "diag::err_undeclared_var_use` for this case. Now, that might add a few more breakpoints than actually needed, but not many, and only rarely in places that were actually covered by this particular run.

Also, since we add the breakpoint after it was seen -- DiagnosticsEngine::Report is called later, and sometimes much later, you'll need to run the debugger again to actually hit all the breakpoints.

Also, What is the workflow for using the "clangdiag diagtool" subcommand? Would you have to do two steps, clangdiag enable and then clangdiag diagtool? If so, maybe it could just be clangdiag enable --diagtool=<path>

I put command script import /Users/dhinton/projects/llvm_project/llvm/tools/clang/utils/clangdiag.py in my ~/.lldbinit file, so here's an example of how I use it:

$ lldb bin/clang-6.0
The "clangdiag" command has been installed, type "help clangdiag" or "clangdiag --help" for detailed help.
(lldb) target create "bin/clang-6.0"
Current executable set to 'bin/clang-6.0' (x86_64).

(lldb) clangdiag diagtool
diagtool = /Users/dhinton/projects/llvm_project/build/Debug/bin/diagtool

(lldb) clangdiag diagtool /bad/path/xx
clangdiag: /bad/path/xx not found.
diagtool = /Users/dhinton/projects/llvm_project/build/Debug/bin/diagtool

(lldb) clangdiag diagtool /Users/dhinton/projects/monorepo/build/Debug/bin/diagtool
diagtool = /Users/dhinton/projects/monorepo/build/Debug/bin/diagtool

(lldb) clangdiag diagtool reset
diagtool = /Users/dhinton/projects/llvm_project/build/Debug/bin/diagtool

(lldb) clangdiag enable
(lldb) br l
Current breakpoints:
1: name = 'DiagnosticsEngine::Report', locations = 33
    Breakpoint commands (Python):
      return clangdiag.setDiagBreakpoint(frame, bp_loc, internal_dict)

  Names:
    clang::Diagnostic

  1.1: where = clang-6.0`clang::DiagnosticsEngine::Report(unsigned int) + 38 at Diagnostic.h:1215, address = clang-6.0[0x0000000100022cd6], unresolved, hit count = 0
  1.2: where = clang-6.0`clang::DiagnosticsEngine::Report(clang::SourceLocation, unsigned int) + 46 at Diagnostic.h:1207, address = clang-6.0[0x000000010002c6ce], unresolved, hit count = 0
<...snip...>

(lldb) clangdiag disable
(lldb) br l
No breakpoints currently set.

(lldb) clangdiag enable
(lldb) br l
Current breakpoints:
2: name = 'DiagnosticsEngine::Report', locations = 33
    Breakpoint commands (Python):
      return clangdiag.setDiagBreakpoint(frame, bp_loc, internal_dict)

  Names:
    clang::Diagnostic

  2.1: where = clang-6.0`clang::DiagnosticsEngine::Report(unsigned int) + 38 at Diagnostic.h:1215, address = clang-6.0[0x0000000100022cd6], unresolved, hit count = 0
  2.2: where = clang-6.0`clang::DiagnosticsEngine::Report(clang::SourceLocation, unsigned int) + 46 at Diagnostic.h:1207, address = clang-6.0[0x000000010002c6ce], unresolved, hit count = 0
<...snip...>

(lldb) run <...>
#### might hit one of the new breakpoints if they are seen more than once
(lldb) run 
#### should hit all the breakpoints for which diagnostics were produced

(lldb) br l
Current breakpoints:
2: name = 'DiagnosticsEngine::Report', locations = 33, resolved = 33, hit count = 5
    Breakpoint commands (Python):
      return clangdiag.setDiagBreakpoint(frame, bp_loc, internal_dict)

  Names:
    clang::Diagnostic
  2.1: where = clang-6.0`clang::DiagnosticsEngine::Report(unsigned int) + 38 at Diagnostic.h:1215, address = 0x0000000100022cd6, resolved, hit count = 0                                                                                        
  2.2: where = clang-6.0`clang::DiagnosticsEngine::Report(clang::SourceLocation, unsigned int) + 46 at Diagnostic.h:1207, address = 0x000000010002c6ce, resolved, hit count = 0
<...snip...>

3: source regex = "err_unknown_typename", exact_match = 0, locations = 6, resolved = 6, hit count = 2                                                                                                                                           Names:                                                                                                                                                                                                                                          clang::Diagnostic

  3.1: where = libclangSema.dylib`clang::Sema::DiagnoseUnknownTypeName(clang::IdentifierInfo*&, clang::SourceLocation, clang::Scope*, clang::CXXScopeSpec*, clang::OpaquePtr<clang::QualType>&, bool) + 1721 at SemaDecl.cpp:677, address = 0x0000000111553ee9, resolved, hit count = 0
<...snip...>

4: source regex = "warn_return_missing_expr", exact_match = 0, locations = 1, resolved = 1, hit count = 0
  Names:
    clang::Diagnostic

  4.1: where = libclangSema.dylib`clang::Sema::BuildReturnStmt(clang::SourceLocation, clang::Expr*) + 3149 at SemaStmt.cpp:3489, address = 0x0000000111db1c6d, resolved, hit count = 0
<...snip...>

5: source regex = "err_expected_lparen_after", exact_match = 0, locations = 39, resolved = 39, hit count = 0
  Names:
    clang::Diagnostic

  5.1: where = libclangParse.dylib`clang::Parser::ConsumeAndStoreFunctionPrologue(llvm::SmallVector<clang::Token, 4u>&) + 527 at ParseCXXInlineMethods.cpp:786, address = 0x0000000110fd74df, resolved, hit count = 0
<...snip...>

6: source regex = "err_undeclared_var_use", exact_match = 0, locations = 11, resolved = 11, hit count = 0
  Names:
    clang::Diagnostic

  6.1: where = libclangSema.dylib`clang::Sema::BuildCXXNestedNameSpecifier(clang::Scope*, clang::Sema::NestedNameSpecInfo&, bool, clang::CXXScopeSpec&, clang::NamedDecl*, bool, bool*, bool) + 5820 at SemaCXXScopeSpec.cpp:630, address = 0x0000000111440ddc, resolved, hit count = 0
<...snip...>

7: source regex = "err_unknown_typename", exact_match = 0, locations = 6, resolved = 6, hit count = 1
  Names:
    clang::Diagnostic

  7.1: where = libclangSema.dylib`clang::Sema::DiagnoseUnknownTypeName(clang::IdentifierInfo*&, clang::SourceLocation, clang::Scope*, clang::CXXScopeSpec*, clang::OpaquePtr<clang::QualType>&, bool) + 1721 at SemaDecl.cpp:677, address = 0x0000000111553ee9, resolved, hit count = 0
<...snip...>

(lldb) clangdiag enable
#### removes all existing breakpoints, then adds back one for DiagnosticsEngine::Report

(lldb) clangdiag disable
#### removes all clangdiag breakpoints

[hintonda]

• Remove debugging print statement, and enhance help message.

[hintonda]

Is there a way to associate a particular diagtool variable to an exe_ctx?

[clayborg]

Each lldb.SBValue has accessors for the stuff in an execution context:

``

lldb::SBTarget GetTarget();
lldb::SBProcess GetProcess();
lldb::SBThread GetThread();
lldb::SBFrame GetFrame();

You could keep a global map of process ID to diagtool if you want?

What are you thinking of using this for?

[hintonda]

• Maintain process id map for diagtool.

[hintonda]

• Add ability to add breakpoints matching -W<warning> warnings.

[hintonda]

• Add support for individual DiagID's, and print out number of breakpoints added.

[hintonda]

• Remove whitespace.

cfe/trunk/utils/clangdiag.py

+#!/usr/bin/python
+
+#----------------------------------------------------------------------
+# Be sure to add the python path that points to the LLDB shared library.
+#
+# # To use this in the embedded python interpreter using "lldb" just
+# import it with the full path using the "command script import"
+# command
+#   (lldb) command script import /path/to/clandiag.py
+#----------------------------------------------------------------------
+
+import lldb
+import argparse
+import commands
+import shlex
+import os
+import re
+import subprocess
+
+class MyParser(argparse.ArgumentParser):
+    def format_help(self):
+        return '''     Commands for managing clang diagnostic breakpoints
+
+Syntax: clangdiag enable [<warning>|<diag-name>]
+        clangdiag disable
+        clangdiag diagtool [<path>|reset]
+
+The following subcommands are supported:
+
+      enable   -- Enable clang diagnostic breakpoints.
+      disable  -- Disable all clang diagnostic breakpoints.
+      diagtool -- Return, set, or reset diagtool path.
+
+This command sets breakpoints in clang, and clang based tools, that
+emit diagnostics.  When a diagnostic is emitted, and clangdiag is
+enabled, it will use the appropriate diagtool application to determine
+the name of the DiagID, and set breakpoints in all locations that
+'diag::name' appears in the source.  Since the new breakpoints are set
+after they are encountered, users will need to launch the executable a
+second time in order to hit the new breakpoints.
+
+For in-tree builds, the diagtool application, used to map DiagID's to
+names, is found automatically in the same directory as the target
+executable.  However, out-or-tree builds must use the 'diagtool'
+subcommand to set the appropriate path for diagtool in the clang debug
+bin directory.  Since this mapping is created at build-time, it's
+important for users to use the same version that was generated when
+clang was compiled, or else the id's won't match.
+
+Notes:
+- Substrings can be passed for both <warning> and <diag-name>.
+- If <warning> is passed, only enable the DiagID(s) for that warning.
+- If <diag-name> is passed, only enable that DiagID.
+- Rerunning enable clears existing breakpoints.
+- diagtool is used in breakpoint callbacks, so it can be changed
+  without the need to rerun enable.
+- Adding this to your ~.lldbinit file makes clangdiag available at startup:
+  "command script import /path/to/clangdiag.py"
+
+'''
+
+def create_diag_options():
+    parser = MyParser(prog='clangdiag')
+    subparsers = parser.add_subparsers(
+        title='subcommands',
+        dest='subcommands',
+        metavar='')
+    disable_parser = subparsers.add_parser('disable')
+    enable_parser = subparsers.add_parser('enable')
+    enable_parser.add_argument('id', nargs='?')
+    diagtool_parser = subparsers.add_parser('diagtool')
+    diagtool_parser.add_argument('path', nargs='?')
+    return parser
+
+def getDiagtool(target, diagtool = None):
+    id = target.GetProcess().GetProcessID()
+    if 'diagtool' not in getDiagtool.__dict__:
+        getDiagtool.diagtool = {}
+    if diagtool:
+        if diagtool == 'reset':
+            getDiagtool.diagtool[id] = None
+        elif os.path.exists(diagtool):
+            getDiagtool.diagtool[id] = diagtool
+        else:
+            print('clangdiag: %s not found.' % diagtool)
+    if not id in getDiagtool.diagtool or not getDiagtool.diagtool[id]:
+        getDiagtool.diagtool[id] = None
+        exe = target.GetExecutable()
+        if not exe.Exists():
+            print('clangdiag: Target (%s) not set.' % exe.GetFilename())
+        else:
+            diagtool = os.path.join(exe.GetDirectory(), 'diagtool')
+            if os.path.exists(diagtool):
+                getDiagtool.diagtool[id] = diagtool
+            else:
+                print('clangdiag: diagtool not found along side %s' % exe)
+
+    return getDiagtool.diagtool[id]
+
+def setDiagBreakpoint(frame, bp_loc, dict):
+    id = frame.FindVariable("DiagID").GetValue()
+    if id is None:
+        print('clangdiag: id is None')
+        return False
+
+    # Don't need to test this time, since we did that in enable.
+    target = frame.GetThread().GetProcess().GetTarget()
+    diagtool = getDiagtool(target)
+    name = subprocess.check_output([diagtool, "find-diagnostic-id", id]).rstrip();
+    # Make sure we only consider errors, warnings, and extentions.
+    # FIXME: Make this configurable?
+    prefixes = ['err_', 'warn_', 'exp_']
+    if len([prefix for prefix in prefixes+[''] if name.startswith(prefix)][0]):
+        bp = target.BreakpointCreateBySourceRegex(name, lldb.SBFileSpec())
+        bp.AddName("clang::Diagnostic")
+
+    return False
+
+def enable(exe_ctx, args):
+    # Always disable existing breakpoints
+    disable(exe_ctx)
+
+    target = exe_ctx.GetTarget()
+    numOfBreakpoints = target.GetNumBreakpoints()
+
+    if args.id:
+        # Make sure we only consider errors, warnings, and extentions.
+        # FIXME: Make this configurable?
+        prefixes = ['err_', 'warn_', 'exp_']
+        if len([prefix for prefix in prefixes+[''] if args.id.startswith(prefix)][0]):
+            bp = target.BreakpointCreateBySourceRegex(args.id, lldb.SBFileSpec())
+            bp.AddName("clang::Diagnostic")
+        else:
+            diagtool = getDiagtool(target)
+            list = subprocess.check_output([diagtool, "list-warnings"]).rstrip();
+            for line in list.splitlines(True):
+                m = re.search(r' *(.*) .*\[\-W' + re.escape(args.id) + r'.*].*', line)
+                # Make sure we only consider warnings.
+                if m and m.group(1).startswith('warn_'):
+                    bp = target.BreakpointCreateBySourceRegex(m.group(1), lldb.SBFileSpec())
+                    bp.AddName("clang::Diagnostic")
+    else:
+        print('Adding callbacks.')
+        bp = target.BreakpointCreateByName('DiagnosticsEngine::Report')
+        bp.SetScriptCallbackFunction('clangdiag.setDiagBreakpoint')
+        bp.AddName("clang::Diagnostic")
+
+    count = target.GetNumBreakpoints() - numOfBreakpoints
+    print('%i breakpoint%s added.' % (count, "s"[count==1:]))
+
+    return
+
+def disable(exe_ctx):
+    target = exe_ctx.GetTarget()
+    # Remove all diag breakpoints.
+    bkpts = lldb.SBBreakpointList(target)
+    target.FindBreakpointsByName("clang::Diagnostic", bkpts)
+    for i in range(bkpts.GetSize()):
+        target.BreakpointDelete(bkpts.GetBreakpointAtIndex(i).GetID())
+
+    return
+
+def the_diag_command(debugger, command, exe_ctx, result, dict):
+    # Use the Shell Lexer to properly parse up command options just like a
+    # shell would
+    command_args = shlex.split(command)
+    parser = create_diag_options()
+    try:
+        args = parser.parse_args(command_args)
+    except:
+        return
+
+    if args.subcommands == 'enable':
+        enable(exe_ctx, args)
+    elif args.subcommands == 'disable':
+        disable(exe_ctx)
+    else:
+        diagtool = getDiagtool(exe_ctx.GetTarget(), args.path)
+        print('diagtool = %s' % diagtool)
+
+    return
+
+def __lldb_init_module(debugger, dict):
+    # This initializer is being run from LLDB in the embedded command interpreter
+    # Make the options so we can generate the help text for the new LLDB
+    # command line command prior to registering it with LLDB below
+    parser = create_diag_options()
+    the_diag_command.__doc__ = parser.format_help()
+    # Add any commands contained in this module to LLDB
+    debugger.HandleCommand(
+        'command script add -f clangdiag.the_diag_command clangdiag')
+    print 'The "clangdiag" command has been installed, type "help clangdiag" or "clangdiag --help" for detailed help.'