#!/usr/bin/python

# ----------------------------------------------------------------------
#
# Be sure to add the python path that points to the LLDB shared library.
# On MacOSX csh, tcsh:
#   setenv PYTHONPATH /Developer/Library/PrivateFrameworks/LLDB.framework/Resources/Python
# On MacOSX sh, bash:
#   export PYTHONPATH=/Developer/Library/PrivateFrameworks/LLDB.framework/Resources/Python
#
# This script collect debugging information using LLDB. This script is
# used by TEST=dbg in llvm testsuite to measure quality of debug info in
# optimized builds.
#
# Usage:
# export PYTHONPATH=...
# ./CollectDebugInfUsingLLDB.py program bp_file out_file
#     program - Executable program with debug info.
#     bp_file - Simple text file listing breakpoints.
#               <absolute file name> <line number>
#     out_file - Output file where the debug info will be emitted.
# ----------------------------------------------------------------------

import lldb
import os
import sys
import time

# AlreadyPrintedValues - A place to keep track of recursive values.
AlreadyPrintedValues = {}

# ISAlreadyPrinted - Return true if value is already printed.
def IsAlreadyPrinted(value_name):
    if AlreadyPrintedValues.get(value_name) is None:
        AlreadyPrintedValues[value_name] = 1
        return False
    return True


# print_var_value - Print a variable's value.
def print_var_value(v, file, frame):
    if v.IsValid() == False:
        return
    if IsAlreadyPrinted(v.GetName()):
        return
    total_children = v.GetNumChildren()
    if total_children > 0:
        c = 0
        while c < total_children:
            child = v.GetChildAtIndex(c)
            if child is None:
                file.write("None")
            else:
                if (child.GetName()) is None:
                    file.write("None")
                else:
                    file.write(child.GetName())
                    file.write("=")
                    print_var_value(child, file, frame)
                    file.write(",")
            c = c + 1
    else:
        if v.GetValue(frame) is None:
            file.write("None")
        else:
            file.write(v.GetValue(frame))


def disable_bp(thread):
    # disable this thread.
    count = thread.GetStopReasonDataCount()
    bid = 0
    tid = 0
    for i in range(count):
        id = thread.GetStopReasonDataAtIndex(i)
        bp = target.FindBreakpointByID(id)
        if bp.IsValid():
            if bp.IsEnabled() == True:
                bid = bp.GetID()
                tid = bp.GetThreadID()
                bp.SetEnabled(False)
                # print " disabled [", str(bp.GetThreadID()), ":", str(bp.GetID()), "]"
        else:
            bp_loc = bp.FindLocationByID(thread.GetStopReasonDataAtIndex(i + 1))
            if bp_loc.IsValid():
                bid = bp_loc.GetBreakPoint().GetID()
                tid = bp_loc.ThreadGetID()
                bp_loc.SetEnabled(False)
                # print " disabled [", str(bp.GetThreadID()), ":", str(bp.GetID()), "]"


# print_vars - Print variable values in output file.
def print_vars(tag, vars, fname, line, file, frame, target, thread):

    bid = 0
    tid = 0
    count = thread.GetStopReasonDataCount()
    # print "count = ",count
    for i in range(count):
        # print "i =", i
        id = thread.GetStopReasonDataAtIndex(i)
        bp = target.FindBreakpointByID(id)
        if bp.IsValid():
            bid = bp.GetID()
            tid = bp.GetThreadID()
            # print "bp is valid", bid, tid
            for j in range(vars.GetSize()):
                v = vars.GetValueAtIndex(j)
                if v.GetName() is not None:
                    file.write(tag)
                    file.write(fname)
                    file.write(":")
                    file.write(str(line))
                    file.write(" ")
                    file.write(str(tid))
                    file.write(":")
                    file.write(str(bid))
                    file.write(" ")
                    file.write(v.GetName())
                    file.write(" ")
                    AlreadyPrintedValues.clear()
                    print_var_value(v, file, frame)
                    file.write("\n")


# set_breakpoints_old - set breakpoints as listed in input file.
def set_breakpoints_old(target, breakpoint_filename, file):
    f = open(breakpoint_filename, "r")
    lines = f.readlines()
    for l in range(len(lines)):
        c = lines[l].split()
        # print "setting break point - ", c
        bp = target.BreakpointCreateByLocation(str(c[0]), int(c[1]))
        file.write("#Breakpoint ")
        file.write(str(c[0]))
        file.write(":")
        file.write(str(c[1]))
        file.write(" ")
        file.write(str(bp.GetThreadID()))
        file.write(":")
        file.write(str(bp.GetID()))
        file.write("\n")
    f.close()


# stopeed_at_breakpoint - Return True if process is stopeed at a
# set_breakpoints - set breakpoints as listed in input file.
def set_breakpoints(target, breakpoint_filename, file):
    f = open(breakpoint_filename, "r")
    lines = f.readlines()
    for l in range(len(lines)):
        l2 = len(lines[l])
        l3 = l2 - 1
        # print "setting break point - ", lines[l][0:l3]
        bp = target.BreakpointCreateByName(str(lines[l][0:l3]))
        # print "setting break point - ", lines[l][0:l3],
        # print " [", str(bp.GetThreadID()), ":", str(bp.GetID()), "]"
        file.write("#Breakpoint ")
        file.write(str(1))
        file.write(":")
        file.write(str(2))
        file.write(" ")
        file.write(str(bp.GetThreadID()))
        file.write(":")
        file.write(str(bp.GetID()))
        file.write(" ")
        file.write(str(lines[l][0:l3]))
        file.write("\n")
    f.close()


# stopeed_at_breakpoint - Return True if process is stopeed at a
# breakpoint.
def stopped_at_breakpoint(process):
    # print "stopped"
    if process.IsValid():
        # print "stopped process"
        state = process.GetState()
        # print "stopped process", state
        if state == lldb.eStateStopped:
            # print "stopped process state is stopped"
            thread = process.GetThreadAtIndex(0)
            if thread.IsValid():
                # print "thread is valid"
                if thread.GetStopReason() == lldb.eStopReasonBreakpoint:
                    # print "thread stopped at breakpoint"
                    return True
    return False


# Create a new debugger instance
debugger = lldb.SBDebugger.Create()

# When we step or continue, don't return from the function until the process
# stops. We do this by setting the async mode to false.
debugger.SetAsync(False)

# Create a target from a file and arch
# print "Creating a target for '%s'" % sys.argv[1]

target = debugger.CreateTargetWithFileAndArch(sys.argv[1], lldb.LLDB_ARCH_DEFAULT)

if target.IsValid():
    # print "target is valid"
    file = open(str(sys.argv[3]), "w")
    set_breakpoints(target, sys.argv[2], file)

    # Launch the process. Since we specified synchronous mode, we won't return
    # from this function until we hit the breakpoint at main
    sberror = lldb.SBError()
    process = target.LaunchSimple(None, None, None)
    # Make sure the launch went ok
    while stopped_at_breakpoint(process):
        # print "stopped at a bp"
        thread = process.GetThreadAtIndex(0)
        # print "num of frames ", thread.GetNumFrames()
        frame = thread.GetFrameAtIndex(0)
        if not frame.IsValid():
            for fi in range(thread.GetNumFrames()):
                # print "checking frame no : ", fi
                frame = thread.GetFrameAtIndex(fi)
                if frame.IsValid():
                    fi = thread.GetNumFrames()
        if frame.IsValid():
            # #Print some simple frame info
            ##print frame
            # print "frame is valid"
            function = frame.GetFunction()
            if function.IsValid():
                fname = function.GetMangledName()
                if fname is None:
                    fname = function.GetName()
                # print "function : ",fname
                line = frame.GetLineEntry().GetLine()
                vars = frame.GetVariables(1, 0, 0, 0)
                print_vars("#Argument ", vars, fname, line, file, frame, target, thread)
                # vars = frame.GetVariables(0,1,0,0)
                # print_vars ("#Variables ", vars, fname, line, file, frame, target, thread)
        disable_bp(thread)
        process.Continue()
    file.close()

lldb.SBDebugger.Terminate()