path: root/testsuite/lib/ltrace.exp

# This file is part of ltrace.
# Copyright (C) 2012, 2013 Petr Machata, Red Hat Inc.
# Copyright (C) 2006 Yao Qi, IBM Corporation
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301 USA

# Generic ltrace test subroutines that should work for any target.  If these
# need to be modified for any target, it can be done with a variable
# or by passing arguments.

source $objdir/env.exp

if [info exists TOOL_EXECUTABLE] {
	set LTRACE $TOOL_EXECUTABLE
} else {
	set LTRACE $objdir/../ltrace
}

if {[info exists VALGRIND] && ![string equal $VALGRIND {}]} {
	verbose "Running under valgrind command: `$VALGRIND'"
	set LTRACE "$VALGRIND $LTRACE"
}

set LTRACE_OPTIONS {}
set LTRACE_ARGS {}
set LTRACE_TEMP_FILES {}

# ltrace_compile SOURCE DEST TYPE OPTIONS 
#
# Compile PUT(program under test) by native compiler.   ltrace_compile runs 
# the right compiler, and TCL captures the output, and I evaluate the output.
#
# SOURCE is the name of program under test, with full directory.
# DEST is the name of output of compilation, with full directory.
# TYPE is an enum-like variable to affect the format or result of compiler
#   output.  Values:
#   executable   if output is an executable.
#   object       if output is an object.
# OPTIONS is option to compiler in this compilation.
proc ltrace_compile {source dest type options} {
    global LTRACE_TESTCASE_OPTIONS;

    if {![string equal "object" $type]} {
	# Add platform-specific options if a shared library was specified using
	# "shlib=librarypath" in OPTIONS.
	set new_options ""
	set shlib_found 0

	foreach opt $options {
	    if [regexp {^shlib=(.*)} $opt dummy_var shlib_name] {
		if [test_compiler_info "xlc*"] {
		    # IBM xlc compiler doesn't accept shared library named other
		    # than .so: use "-Wl," to bypass this
		    lappend source "-Wl,$shlib_name"
		} else {
		    lappend source $shlib_name
		}

		if {$shlib_found == 0} {
		    set shlib_found 1

		    if { ([test_compiler_info "gcc-*"]&& ([istarget "powerpc*-*-aix*"]|| [istarget "rs6000*-*-aix*"] ))} {
			lappend options "additional_flags=-L${objdir}/${subdir}"
		    } elseif { [istarget "mips-sgi-irix*"] } {
			lappend options "additional_flags=-rpath ${objdir}/${subdir}"
		    }
		}

	    } else {
		lappend new_options $opt
	    }
	}

	#end of for loop
	set options $new_options
    }

    # dump some information for debug purpose.
    verbose "options are $options"
    verbose "source is $source $dest $type $options"

    # Wipe the DEST file, so that we don't end up running an obsolete
    # version of the binary.
    exec rm -f $dest

    set result [target_compile $source $dest $type $options];
    verbose "result is $result"
    regsub "\[\r\n\]*$" "$result" "" result;
    regsub "^\[\r\n\]*" "$result" "" result;
    if { $result != "" && [lsearch $options quiet] == -1} {
	clone_output "compile failed for ltrace test, $result"
    }
    return $result;
}

proc get_compiler_info {binfile args} {
    # For compiler.c and compiler.cc
    global srcdir

    # I am going to play with the log to keep noise out.
    global outdir
    global tool

    # These come from compiler.c or compiler.cc
    global compiler_info

    # Legacy global data symbols.
    #global gcc_compiled

    # Choose which file to preprocess.
    set ifile "${srcdir}/lib/compiler.c"
    if { [llength $args] > 0 && [lindex $args 0] == "c++" } {
	    set ifile "${srcdir}/lib/compiler.cc"
    }

    # Run $ifile through the right preprocessor.
    # Toggle ltrace.log to keep the compiler output out of the log.
    #log_file
    set cppout [ ltrace_compile "${ifile}" "" preprocess [list "$args" quiet] ]
    #log_file -a "$outdir/$tool.log" 

    # Eval the output.
    set unknown 0
    foreach cppline [ split "$cppout" "\n" ] {
	    if { [ regexp "^#" "$cppline" ] } {
	      # line marker
	    } elseif { [ regexp "^\[\n\r\t \]*$" "$cppline" ] } {
	      # blank line
	    } elseif { [ regexp "^\[\n\r\t \]*set\[\n\r\t \]" "$cppline" ] } {
	    # eval this line
	      verbose "get_compiler_info: $cppline" 2
	      eval "$cppline"
	  } else {
	    # unknown line
	    verbose "get_compiler_info: $cppline"
	    set unknown 1
	  }
      }

    # Reset to unknown compiler if any diagnostics happened.
    if { $unknown } {
	    set compiler_info "unknown"
    }
  return 0
}

proc test_compiler_info { {compiler ""} } {
    global compiler_info

     if [string match "" $compiler] {
         if [info exists compiler_info] {
	     verbose "compiler_info=$compiler_info"
	     # if no arg, return the compiler_info string
             return $compiler_info
         } else {
             perror "No compiler info found."
         }
     }

    return [string match $compiler $compiler_info]
}

proc ltrace_compile_shlib {sources dest options} {
    set obj_options $options
    verbose "+++++++ [test_compiler_info]" 
    switch -glob [test_compiler_info] {
	"xlc-*" {
	    lappend obj_options "additional_flags=-qpic"
	}
	"gcc-*" {
	    if { !([istarget "powerpc*-*-aix*"]
		   || [istarget "rs6000*-*-aix*"]) } {
                lappend obj_options "additional_flags=-fpic"
	    }
          }
  "xlc++-*" {
      lappend obj_options "additional_flags=-qpic"
  }

	default {
	    fail "Bad compiler!"
            }
    }

    if {![LtraceCompileObjects $sources $obj_options objects]} {
	return -1
    }

    set link_options $options
    if { [test_compiler_info "xlc-*"] || [test_compiler_info "xlc++-*"]} {
	lappend link_options "additional_flags=-qmkshrobj"
    } else {
	lappend link_options "additional_flags=-shared"
    }
    if {[ltrace_compile "${objects}" "${dest}" executable $link_options] != ""} {
	return -1
    }

    return
}

# WipeFiles --
#
#	Delete each file in the list.
#
# Arguments:
#	files	List of files to delete.
#
# Results:
#	Each of the files is deleted.  Files are deleted in reverse
#	order, so that directories are emptied and can be deleted
#	without using -force.  Returns nothing.

proc WipeFiles {files} {
    verbose "WipeFiles: $files\n"
    foreach f [lreverse $files] {
	file delete $f
    }
}

# LtraceTmpDir --
#
#	Guess what directory to use for temporary files.
#	This was adapted from http://wiki.tcl.tk/772
#
# Results:
#	A temporary directory to use.  The current directory if no
#	other seems to be available.

proc LtraceTmpDir {} {
    set tmpdir [pwd]

    if {[file exists "/tmp"]} {
	set tmpdir "/tmp"
    }

    catch {set tmpdir $::env(TMP)}
    catch {set tmpdir $::env(TEMP)}
    catch {set tmpdir $::env(TMPDIR)}

    return $tmpdir
}

set LTRACE_TEMP_DIR [LtraceTmpDir]

# LtraceTempFile --
#
#	Create a temporary file according to a pattern, and return its
#	name.  This behaves similar to mktemp.  We don't use mktemp
#	directly, because on older systems, mktemp requires that the
#	array of X's be at the very end of the string, while ltrace
#	temporary files need to have suffixes.
#
# Arguments:
#	pat	Pattern to use.  See mktemp for description of its format.
#
# Results:
#	Creates the temporary file and returns its name.  The name is
#	also appended to LTRACE_TEMP_FILES.

proc LtraceTempFile {pat} {
    global LTRACE_TEMP_FILES
    global LTRACE_TEMP_DIR

    set letters "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    set numLetters [string length $letters]

    if {![regexp -indices {(X{3,})} $pat m]} {
	send_error -- "Pattern $pat contains insufficient number of X's."
	return {}
    }

    set start [lindex $m 0]
    set end [lindex $m 1]
    set len [expr {$end - $start + 1}]

    for {set j 0} {$j < 10} {incr j} {

	# First, generate a random name.

	set randstr {}
	for {set i 0} {$i < $len} {incr i} {
	    set r [expr {int(rand() * $numLetters)}]
	    append randstr [string index $letters $r]
	}
	set prefix [string range $pat 0 [expr {$start - 1}]]
	set suffix [string range $pat [expr {$end + 1}] end]
	set name [file join $LTRACE_TEMP_DIR "$prefix$randstr$suffix"]

	# Now check that it's free.  This is of course racy, but this
	# is a test suite, not anything used in actual production.

	if {[file exists $name]} {
	    continue
	}

	# We don't bother attempting to open the file.  Downstream
	# code can do it itself.

	lappend LTRACE_TEMP_FILES $name
	return $name
    }

    send_error -- "Couldn't create a temporary file for pattern $pat."
    return
}

# ltraceNamedSource --
#
#	Create a file named FILENAME, and prime it with TEXT.  If
#	REMEMBERTEMP, add the file into LTRACE_TEMP_FILES, so that
#	ltraceDone (or rather WipeFiles) erases it later.
#
# Arguments:
#	filename	Name of the file to create.
#
#	text	Contents of the new file.
#
#	rememberTemp	Whether to add filename to LTRACE_TEMP_FILES.
#
# Results:
#	Returns $filename, which now refers to a file with contents
#	given by TEXT.

proc ltraceNamedSource {filename text {rememberTemp 1}} {
    global LTRACE_TEMP_FILES

    set chan [open $filename w]
    puts $chan $text
    close $chan

    if $rememberTemp {
	lappend LTRACE_TEMP_FILES $filename
    }

    return $filename
}

# ltraceSource --
#
#	Create a temporary file with a given suffix and prime it with
#	contents given in text.
#
# Arguments:
#	suffix	Suffix of the temp file to be created.
#
#	text	Contents of the new file.
#
# Results:
#	Returns file name of created file.

proc ltraceSource {suffix text} {
    return [ltraceNamedSource \
		[LtraceTempFile "lt-XXXXXXXXXX.$suffix"] $text 0]
}

# ltraceDir --
#
#	Create a temporary directory.
#
# Arguments:
#
# Results:
#	Returns name of created directory.

proc ltraceDir {} {
    set ret [LtraceTempFile "lt-XXXXXXXXXX.dir"]
    file mkdir $ret
    return $ret
}

# LtraceCompileObjects --
#
#	Compile each source file into an object file.  ltrace_compile
#	is called to perform actual compilation.
#
# Arguments:
#	sources	List of source files.
#
#	options	Options for ltrace_compile.
#
#	retName Variable where the resulting list of object names is
#		to be placed.
# Results:
#	Returns true or false depending on whether there were any
#	errors.  If it returns true, then variable referenced by
#	retName contains list of object files, produced by compiling
#	files in sources list.

proc LtraceCompileObjects {sources options retName} {
    global LTRACE_TEMP_FILES
    upvar $retName ret
    set ret {}

    foreach source $sources {
	set sourcebase [file tail $source]
	set dest $source.o
	lappend LTRACE_TEMP_FILES $dest
	verbose "LtraceCompileObjects: $source -> $dest"
	if {[ltrace_compile $source $dest object $options] != ""} {
	    return false
	}
	lappend ret $dest
    }

    return true
}

# ltraceCompile --
#
#	This attempts to compile a binary from sources given in ARGS.
#
# Arguments:
#	dest	A binary to be produced.  If this is called lib*.so, then
#		the resulting binary will be a library, if *.pie, it
#		will be a PIE, otherwise it will be an executable.  In
#		theory this could also be *.o for "object" and *.i for
#		"preprocess" for cases with one source file, but that
#		is not supported at the moment.  The binary will be
#		placed in $objdir/$subdir.
#
#	args	List of options and source files.
#
#		Options are arguments that start with a dash.  Options
#		(sans the dash) are passed to ltrace_compile.
#
#		Source files named lib*.so are libraries.  Those are
#		passed to ltrace_compile as options shlib=X.  Source
#		files named *.o are objects.  The remaining source
#		files are first compiled (by LtraceCompileObjects) and
#		then together with other objects passed to
#		ltrace_compile to produce resulting binary.
#
#		Any argument that is empty string prompts the function
#		to fail.  This is done so that errors caused by
#		ltraceSource (or similar) distribute naturally
#		upwards.
#
# Results:
#	This compiles given source files into a binary.  Full file name
#	of that binary is returned.  Empty string is returned in case
#	of a failure.

proc ltraceCompile {dest args} {
    global objdir
    global subdir

    get_compiler_info {} c
    get_compiler_info {} c++

    if {[string match "lib*.so" $dest]} {
	set type "library"
	set extraObjOptions "additional_flags=-fpic"
	set extraOptions "additional_flags=-shared"
    } elseif {[string match "*.pie" $dest]} {
	set type "executable"
	set extraObjOptions "additional_flags=-fpic"
	set extraOptions "additional_flags=-pie"
    } else {
	set type "executable"
	set extraObjOptions {}
	set extraOptions {}
    }

    set options {}
    set sources {}
    set objects {}
    foreach a $args {
	if {[string match "-l*" $a]} {
	    lappend options "shlib=$a"
	} elseif {[string match "-?*" $a]} {
	    lappend options [string range $a 1 end]
	} elseif {[string match "*.so" $a]} {
	    lappend options "shlib=$a"
	} elseif {[string match "*.o" $a]} {
	    lappend objects $a
	} else {
	    lappend sources $a
	}
    }

    if {[string equal $dest {}]} {
	set dest [LtraceTempFile "exe-XXXXXXXXXX"]
    } elseif {[string equal $dest ".pie"]} {
	set dest [LtraceTempFile "pie-XXXXXXXXXX"]
    } else {
	set dest $objdir/$subdir/$dest
    }

    verbose "ltraceCompile: dest $dest"
    verbose "             : options $options"
    verbose "             : sources $sources"
    verbose "             : objects $objects"

    if {![LtraceCompileObjects $sources \
	      [concat $options $extraObjOptions] newObjects]} {
	return {}
    }
    set objects [concat $objects $newObjects]

    verbose "ltraceCompile: objects $objects"

    if {[ltrace_compile $objects $dest $type \
	     [concat $options $extraOptions]] != ""} {
	return {}
    }

    return $dest
}

# ltraceRun --
#
#	Invoke command identified by LTRACE global variable with given
#	ARGS.  A logfile redirection is automatically ordered by
#	passing -o and a temporary file name.
#
# Arguments:
#	args	Arguments to ltrace binary.
#
# Results:
#	Returns name of logfile.  The "exec" command that it uses
#	under the hood fails loudly if the process exits with a
#	non-zero exit status, or uses stderr in any way.

proc ltraceRun {args} {
    global LTRACE
    global objdir
    global subdir

    set LdPath [ld_library_path $objdir/$subdir]
    set logfile [ltraceSource ltrace {}]

    # Run ltrace.  expect will show an error if this doesn't exit with
    # zero exit status (i.e. ltrace fails, valgrind finds errors,
    # etc.).

    set command "exec env LD_LIBRARY_PATH=$LdPath $LTRACE -o $logfile $args"
    verbose $command
    if {[catch {eval $command}] } {
	fail "test case execution failed"
	send_error -- $command
	send_error -- $::errorInfo
    }

    return $logfile
}

# ltraceDone --
#
#	Wipes or dumps all temporary files after a test suite has
#	finished.
#
# Results:
#	Doesn't return anything.  Wipes all files gathered in
#	LTRACE_TEMP_FILES.  If SAVE_TEMPS is defined and true, the
#	temporary files are not wiped, but their names are dumped
#	instead.  Contents of LTRACE_TEMP_FILES are deleted in any
#	case.

proc ltraceDone {} {
    global SAVE_TEMPS
    global LTRACE_TEMP_FILES

    if {[info exists SAVE_TEMPS] && $SAVE_TEMPS} {
	foreach tmp $LTRACE_TEMP_FILES {
	    send_user "$tmp\n"
	}
    } else {
	WipeFiles $LTRACE_TEMP_FILES
    }

    set LTRACE_TEMP_FILES {}
    return
}

# Grep --
#
#	Return number of lines in a given file, matching a given
#	regular expression.
#
# Arguments:
#	logfile	File to search through.
#
#	re	Regular expression to match.
#
# Results:
#	Returns number of matching lines.

proc Grep {logfile re} {
    set count 0
    set fp [open $logfile]
    while {[gets $fp line] >= 0} {
	if [regexp -- $re $line] {
	    incr count
	}
    }
    close $fp
    return $count
}

# ltraceMatch1 --
#
#	Look for a pattern in a given logfile, comparing number of
#	occurences of the pattern with expectation.
#
# Arguments:
#	logfile	The name of file where to look for patterns.
#
#	pattern	Regular expression pattern to look for.
#
#	op	Operator to compare number of occurences.
#
#	expect	Second operand to op, the first being number of
#		occurences of pattern.
#
# Results:
#	Doesn't return anything, but calls fail or pass depending on
#	whether the patterns matches expectation.

proc ltraceMatch1 {logfile pattern {op ==} {expect 1}} {
    set count [Grep $logfile $pattern]
    set msgMain "$pattern appears in $logfile $count times"
    set msgExpect ", expected $op $expect"

    if {[eval expr $count $op $expect]} {
	pass $msgMain
    } else {
	fail $msgMain$msgExpect
    }
    return
}

# ltraceMatch --
#
#	Look for series of patterns in a given logfile, comparing
#	number of occurences of each pattern with expectations.
#
# Arguments:
#	logfile	The name of file where to look for patterns.
#
#	patterns List of patterns to look for.  ltraceMatch1 is called
#		on each of these in turn.
#
# Results:
#
#	Doesn't return anything, but calls fail or pass depending on
#	whether each of the patterns holds.

proc ltraceMatch {logfile patterns} {
    foreach pat $patterns {
	eval ltraceMatch1 [linsert $pat 0 $logfile]
    }
    return
}

# ltraceLibTest --
#
#	Generate a binary, a library (liblib.so) and a config file.
#	Run the binary using ltraceRun, passing it -F to load the
#	config file.
#
# Arguments:
#	conf	Contents of ltrace config file.
#
#	cdecl	Contents of header file.
#
#	libcode	Contents of library implementation file.
#
#	maincode	Contents of function "main".
#
#	params	Additional parameters to pass to ltraceRun.
#
# Results:
#
#	Returns whatever ltraceRun returns.

proc ltraceLibTest {conf cdecl libcode maincode {params ""}} {
    set conffile [ltraceSource conf $conf]
    set lib [ltraceCompile liblib.so [ltraceSource c [concat $cdecl $libcode]]]
    set bin [ltraceCompile {} $lib \
		 [ltraceSource c \
		      [concat $cdecl "int main(void) {" $maincode "}"]]]

    return [eval [concat "ltraceRun -F $conffile " $params "-- $bin"]]
}

#
# ltrace_options OPTIONS_LIST
# Pass ltrace commandline options.
# 
proc ltrace_options { args } {
	
	global LTRACE_OPTIONS
	set LTRACE_OPTIONS $args
}

#
# ltrace_args ARGS_LIST
# Pass ltrace'd program its own commandline options.
#
proc ltrace_args { args } {

	global LTRACE_ARGS
	set LTRACE_ARGS $args
}

#
# handle run-time library paths
#
proc ld_library_path { args } {

	set ALL_LIBRARY_PATHS { }
	if [info exists LD_LIBRARY_PATH] {
		lappend ALL_LIBRARY_PATHS $LD_LIBRARY_PATH
	}
	global libelf_LD_LIBRARY_PATH
	if {[string length $libelf_LD_LIBRARY_PATH] > 0} {
		lappend ALL_LIBRARY_PATHS $libelf_LD_LIBRARY_PATH
	}
	global libunwind_LD_LIBRARY_PATH
	if {[string length $libunwind_LD_LIBRARY_PATH] > 0} {
		lappend ALL_LIBRARY_PATHS $libunwind_LD_LIBRARY_PATH
	}
	lappend ALL_LIBRARY_PATHS $args
	join $ALL_LIBRARY_PATHS ":"
}

#
# ltrace_runtest LD_LIBRARY_PATH BIN FILE
# Trace the execution of BIN and return result.
#
# BIN is program-under-test.
# LD_LIBRARY_PATH is the env for program-under-test to run.
# FILE is to save the output from ltrace with default name $BIN.ltrace.
# Retrun output from ltrace.
#
proc ltrace_runtest { args } {

	global LTRACE
	global LTRACE_OPTIONS
	global LTRACE_ARGS

	verbose "LTRACE = $LTRACE"
	
	set LD_LIBRARY_PATH_ [ld_library_path [lindex $args 0]]
	set BIN [lindex $args 1]

	# specify the output file, the default one is $BIN.ltrace
	if [llength $args]==3 then {
		set file [lindex $args 2]
	} else {
		set file $BIN.ltrace
	}

	# Remove the file first.  If ltrace fails to overwrite it, we
	# would be comparing output to an obsolete run.
	exec rm -f $file

	# append this option to LTRACE_OPTIONS.
	lappend LTRACE_OPTIONS "-o"
	lappend LTRACE_OPTIONS "$file"
	verbose "LTRACE_OPTIONS = $LTRACE_OPTIONS"
	set command "exec sh -c {export LD_LIBRARY_PATH=$LD_LIBRARY_PATH_; \
		$LTRACE $LTRACE_OPTIONS $BIN $LTRACE_ARGS;exit}"
	#ltrace the PUT.
	if {[catch $command output]} {
	    fail "test case execution failed"
	    send_error -- $command
	    send_error -- $::errorInfo
	}

	# return output from ltrace.
	return $output
}

#
# ltrace_verify_output FILE_TO_SEARCH PATTERN MAX_LINE
# Verify the ltrace output by comparing the number of PATTERN in 
# FILE_TO_SEARCH with INSTANCE_NO.  Do not specify INSTANCE_NO if
# instance number is ignored in this test.
# Reutrn:
#      0 = number of PATTERN in FILE_TO_SEARCH inqual to INSTANCE_NO.
#      1 = number of PATTERN in FILE_TO_SEARCH qual to INSTANCE_NO.
#
proc ltrace_verify_output { file_to_search pattern {instance_no 0} {grep_command "grep"}} {

	# compute the number of PATTERN in FILE_TO_SEARCH by grep and wc.
	catch "exec sh -c {$grep_command \"$pattern\" $file_to_search | wc -l ;exit}" output
	verbose "output = $output"

	if [ regexp "syntax error" $output ] then {
		fail "Invalid regular expression $pattern"
        } elseif { $instance_no == 0 } then {
		if { $output == 0 } then {
			fail "Fail to find $pattern in $file_to_search"
		} else {
			pass "$pattern in $file_to_search"
		}
	} elseif { $output >= $instance_no } then {
		pass "$pattern in $file_to_search for $output times"
	} else {
		fail "$pattern in $file_to_search for $output times, should be $instance_no"
	}
}