#!/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()