Changes for GCC 4.9 and OP

Change-Id: I95ddff4b290fcf3eab617a674afc489698c78a1e
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/31563
Reviewed-by: Martha Broyles <mbroyles@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: William A. Bryan <wilbryan@us.ibm.com>

6 files changed, 2007 insertions, 9 deletions

diff --git a/src/tools/check-sensors.sh b/src/tools/check-sensors.sh
index 450c4e6..39ed157 100755
--- a/src/tools/check-sensors.sh
+++ b/src/tools/check-sensors.sh
@@ -38,7 +38,7 @@ SCRIPTNAME=`basename "$0"`
 
 # Check that we have two arguments
 if [ $# -ne 2 ]; then
-    echo ${SCRIPTNAME}: usage: ${SCRIPTNAME} /path/to/powerpc-objdump /path/to/occ_405/sensor/
+    echo ${SCRIPTNAME}: usage: ${SCRIPTNAME} /path/to/powerpc-objdump /path/to/obj/occ_405/
     exit 1
 fi
 
@@ -48,11 +48,11 @@ READELF=`which readelf`
 
 # Assign arguments to coherent variables
 OBJDUMP=$1
-SENSOR_PATH=$2
+OBJ_PATH=$2
 
 # Object files that contain the sensor lists
-SENSOR_TABLE=${SENSOR_PATH}/sensor_table.o
-SENSOR_INFO=${SENSOR_PATH}/sensor_info.o
+OCC_405_OUT=${OBJ_PATH}/occ_405.out
+SENSOR_INFO=${OBJ_PATH}/sensor/sensor_info.o
 
 # Keep track of if a sensor is missing from a list
 ERROR=0
@@ -63,8 +63,10 @@ ERROR=0
 # is an array of pointers. On the 405 processor, pointers
 # are 4 bytes, so this looks for any lines in the objdump
 # output that are NULL pointers, indicating either a missing
-# sensor or one that was improperly implemented.
-NUM_ZERO_ENTRIES=$(${OBJDUMP} -Dz ${SENSOR_TABLE} \
+# sensor or one that was improperly implemented. We have to
+# dump the full 405 binary because later gcc versions don't
+# add the sensor addresses until after linking.
+NUM_ZERO_ENTRIES=$(${OBJDUMP} -Dz ${OCC_405_OUT} \
       | awk -v RS= '/^[[:xdigit:]].*<G_amec_sensor_list>/' \
       | grep .long\ 0x0 \
       | ${WC} -l)
@@ -93,6 +95,4 @@ if [ ${NUM_ZERO_ENTRIES} -ne 0 ]; then
     ERROR=1
 fi
 
-if [ ${ERROR} -ne 0 ]; then
-    exit 1
-fi
+exit ${ERROR}
diff --git a/src/tools/tracepp/.gitignore b/src/tools/tracepp/.gitignore
new file mode 100644
index 0000000..8136910
--- /dev/null
+++ b/src/tools/tracepp/.gitignore
@@ -0,0 +1 @@
+tracepp
diff --git a/src/tools/tracepp/jhash.h b/src/tools/tracepp/jhash.h
new file mode 100755
index 0000000..5de3f69
--- /dev/null
+++ b/src/tools/tracepp/jhash.h
@@ -0,0 +1,167 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/tracepp/jhash.h $                                         */
+/*                                                                        */
+/* OpenPOWER OnChipController Project                                     */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2014,2016                        */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* Licensed under the Apache License, Version 2.0 (the "License");        */
+/* you may not use this file except in compliance with the License.       */
+/* You may obtain a copy of the License at                                */
+/*                                                                        */
+/*     http://www.apache.org/licenses/LICENSE-2.0                         */
+/*                                                                        */
+/* Unless required by applicable law or agreed to in writing, software    */
+/* distributed under the License is distributed on an "AS IS" BASIS,      */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
+/* implied. See the License for the specific language governing           */
+/* permissions and limitations under the License.                         */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+#ifndef _LINUX_JHASH_H
+#define _LINUX_JHASH_H
+
+/* jhash.h: Jenkins hash support.
+ *
+ * Copyright (C) 1996 Bob Jenkins (bob_jenkins@burtleburtle.net)
+ *
+ * http://burtleburtle.net/bob/hash/
+ *
+ * These are the credits from Bob's sources:
+ *
+ * lookup2.c, by Bob Jenkins, December 1996, Public Domain.
+ * hash(), hash2(), hash3, and mix() are externally useful functions.
+ * Routines to test the hash are included if SELF_TEST is defined.
+ * You can use this free for any purpose.  It has no warranty.
+ *
+ * Copyright (C) 2003 David S. Miller (davem@redhat.com)
+ *
+ * I've modified Bob's hash to be useful in the Linux kernel, and
+ * any bugs present are surely my fault.  -DaveM
+ */
+
+/* NOTE: Arguments are modified. */
+#define __jhash_mix(a, b, c) \
+{ \
+  a -= b; a -= c; a ^= (c>>13); \
+  b -= c; b -= a; b ^= (a<<8); \
+  c -= a; c -= b; c ^= (b>>13); \
+  a -= b; a -= c; a ^= (c>>12);  \
+  b -= c; b -= a; b ^= (a<<16); \
+  c -= a; c -= b; c ^= (b>>5); \
+  a -= b; a -= c; a ^= (c>>3);  \
+  b -= c; b -= a; b ^= (a<<10); \
+  c -= a; c -= b; c ^= (b>>15); \
+}
+
+/* The golden ration: an arbitrary value */
+#define JHASH_GOLDEN_RATIO  0x9e3779b9
+
+/* The most generic version, hashes an arbitrary sequence
+ * of bytes.  No alignment or length assumptions are made about
+ * the input key.
+ */
+static inline u32 jhash(const void *key, u32 length, u32 initval)
+{
+    u32 a, b, c, len;
+    const u8 *k = (const u8*)key;
+
+    len = length;
+    a = b = JHASH_GOLDEN_RATIO;
+    c = initval;
+
+    while (len >= 12) {
+        a += (k[0] +((u32)k[1]<<8) +((u32)k[2]<<16) +((u32)k[3]<<24));
+        b += (k[4] +((u32)k[5]<<8) +((u32)k[6]<<16) +((u32)k[7]<<24));
+        c += (k[8] +((u32)k[9]<<8) +((u32)k[10]<<16)+((u32)k[11]<<24));
+
+        __jhash_mix(a,b,c);
+
+        k += 12;
+        len -= 12;
+    }
+
+    c += length;
+    switch (len) {
+        case 11: c += ((u32)k[10]<<24);
+        case 10: c += ((u32)k[9]<<16);
+        case 9 : c += ((u32)k[8]<<8);
+        case 8 : b += ((u32)k[7]<<24);
+        case 7 : b += ((u32)k[6]<<16);
+        case 6 : b += ((u32)k[5]<<8);
+        case 5 : b += k[4];
+        case 4 : a += ((u32)k[3]<<24);
+        case 3 : a += ((u32)k[2]<<16);
+        case 2 : a += ((u32)k[1]<<8);
+        case 1 : a += k[0];
+    };
+
+    __jhash_mix(a,b,c);
+
+    return c;
+}
+
+/* A special optimized version that handles 1 or more of u32s.
+ * The length parameter here is the number of u32s in the key.
+ */
+static inline u32 jhash2(const u32 *k, u32 length, u32 initval)
+{
+    u32 a, b, c, len;
+
+    a = b = JHASH_GOLDEN_RATIO;
+    c = initval;
+    len = length;
+
+    while (len >= 3) {
+        a += k[0];
+        b += k[1];
+        c += k[2];
+        __jhash_mix(a, b, c);
+        k += 3; len -= 3;
+    }
+
+    c += length * 4;
+
+    switch (len) {
+        case 2 : b += k[1];
+        case 1 : a += k[0];
+    };
+
+    __jhash_mix(a,b,c);
+
+    return c;
+}
+
+
+/* A special ultra-optimized versions that knows they are hashing exactly
+ * 3, 2 or 1 word(s).
+ *
+ * NOTE: In partilar the "c += length; __jhash_mix(a,b,c);" normally
+ *       done at the end is not done here.
+ */
+static inline u32 jhash_3words(u32 a, u32 b, u32 c, u32 initval)
+{
+    a += JHASH_GOLDEN_RATIO;
+    b += JHASH_GOLDEN_RATIO;
+    c += initval;
+
+    __jhash_mix(a, b, c);
+
+    return c;
+}
+
+static inline u32 jhash_2words(u32 a, u32 b, u32 initval)
+{
+    return jhash_3words(a, b, 0, initval);
+}
+
+static inline u32 jhash_1word(u32 a, u32 initval)
+{
+    return jhash_3words(a, 0, 0, initval);
+}
+
+#endif /* _LINUX_JHASH_H */
diff --git a/src/tools/tracepp/makefile b/src/tools/tracepp/makefile
new file mode 100644
index 0000000..e3032ed
--- /dev/null
+++ b/src/tools/tracepp/makefile
@@ -0,0 +1,31 @@
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/tools/tracepp/makefile $
+#
+# OpenPOWER OnChipController Project
+#
+# Contributors Listed Below - COPYRIGHT 2011,2016
+# [+] International Business Machines Corp.
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+
+ifndef PPETOOLS_OBJDIR
+export PPETOOLS_OBJDIR = ../../../obj/ppetools
+endif
+
+$(PPETOOLS_OBJDIR)/tracepp: tracepp.C jhash.h
+	g++ -O3 -w -g -I. $< -o $@
diff --git a/src/tools/tracepp/tracehash.pl b/src/tools/tracepp/tracehash.pl
new file mode 100755
index 0000000..9004067
--- /dev/null
+++ b/src/tools/tracepp/tracehash.pl
@@ -0,0 +1,897 @@
+#!/usr/bin/perl -w
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/tools/tracepp/tracehash.pl $
+#
+# OpenPOWER OnChipController Project
+#
+# Contributors Listed Below - COPYRIGHT 2011,2016
+# [+] International Business Machines Corp.
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+
+
+use strict;
+
+sub determine_args();
+sub launch_cpp_and_parse($$);
+sub cpp_dir($);
+sub read_string_file();
+sub collect_files($);
+sub assimilate_file($);
+sub hash_strings();
+sub write_string_file();
+sub help();
+
+select (STDERR);
+$| = 1; # Make all prints to STDERR flush the buffer immediately
+select (STDOUT);
+$| = 1; # Make all prints to STDOUT flush the buffer immediately
+
+# Constants
+my $HEAD_SEP = "|||";
+my $HEAD_EYE_CATCHER = "#FSP_TRACE_v";
+my $HEAD_BUILD_FLAG = "BUILD:";
+my $HEAD_VER_FLAG = 2;
+my $BB_STRING_FILE = "/opt/fsp/etc/BB_StringFile";
+
+# Global Variables
+my $debug = 0;
+my $seperator = "&&&&";
+my $file_name = "trexStringFile";
+my $in_sand;
+my ($backing) = $ENV{'bb'};
+my $hash_prog = "trexhash";    #default to in path
+my $build = "";
+my ($sandbox) = $ENV{'SANDBOX'} || "";
+my ($context) = $ENV{'CONTEXT'} || "";
+my ($sandboxbase) = $ENV{'SANDBOXBASE'} || "";
+my ($bb);
+my ($sourcebase) = "$sandboxbase/src";
+my ($version) = $HEAD_VER_FLAG; # default to oldest version
+my ($collect) = 0;
+my ($INCLUDE, $Arg, $file, $dir, $string_file);
+my $args = "";
+
+my $fail_on_collision = 0; # 1 = exit with error if hash collision occurs
+my $hash_filename_too = 0; # 1 = hash is calculated over format string + filename
+
+print "sourcebase = $sourcebase\n" if $debug;
+print "sandbox = $sandbox\n" if $debug;
+print "backing = $backing\n" if $debug;
+print "context = $context\n" if $debug;
+
+if ($context =~ /x86/)
+{
+    $bb = "i586-pc-linux-gnu";
+}
+else
+{
+    $bb = "powerpc-linux";
+}
+
+if(($sourcebase =~ /\w+/) && ($sandbox =~ /\w+/))
+{
+    $INCLUDE = "-I $sandboxbase/export/$context/fips/include  -I $backing/export/$context/fips/include -I /opt/fsp/$bb/include/fsp -I/opt/fsp/$bb/include/ -include /opt/fsp/$bb/include/fsp/tracinterface.H";
+}
+else
+{
+    print "Not in Sandbox so guessing Include Paths...\n" if $debug;
+    $INCLUDE = "-I/opt/fsp/i586-pc-linux-gnu/include/fsp -I/opt/fsp/i586-pc-linux-gnu/include/ -include /opt/fsp/i586-pc-linux-gnu/include/fsp/tracinterface.H";
+}
+
+# I/P Series work in ODE sandbox env.
+if ($sandboxbase =~ /\w+/)
+{
+    $in_sand = 1;
+    print "backing = $backing\n" if $debug;
+}
+else
+{
+    $in_sand = 0;
+}
+
+
+
+#  Parse the input parameters.
+
+while (@ARGV) {
+    $Arg = shift;
+
+    if ($Arg eq "-h" || $Arg eq "-H") {
+        help();
+        exit(127);
+    }
+    if ($Arg eq "-f") {
+        $file = shift;
+        next;
+    }
+    if ($Arg eq "-d") {
+        $dir = shift;
+        next;
+    }
+    if ($Arg eq "-s") {
+        $string_file = shift;
+        next;
+    }
+    if ($Arg eq "-c") {
+        $collect = 1;
+        next;
+    }
+    if ($Arg eq "-v") {
+        $debug = 1;
+        print "debug on\n" if $debug;
+        next;
+    }
+    if ($Arg eq "-C") { # fail if a hash collision is detected
+        $fail_on_collision = 1;
+        next;
+    }
+    if ($Arg eq "-F") { # hash is calculated over format string + file name
+        $hash_filename_too = 1;
+        next;
+    }
+    if ($Arg eq "-S") {
+        $BB_STRING_FILE = "";
+        next;
+    }
+
+    #just pass it onto compiler
+    $args = $args . " " . $Arg;
+}
+
+print "args = $args\n" if $debug;
+
+if (!$file && !$dir && !$in_sand) {
+    help();
+    exit(127);
+}
+
+#################################
+#          M A I N              #
+#################################
+
+my $clock = `date`;
+
+$build = $HEAD_EYE_CATCHER . "$HEAD_VER_FLAG" . $HEAD_SEP . $clock . $HEAD_SEP  . $HEAD_BUILD_FLAG;
+
+$build =~ s/\n//g;
+
+# Global array to hold the parsed TRAC macro calls.
+my @strings = ();
+
+# Assoc. arrays to hold hash|string values.
+my %string_file_array = ();
+my %hash_strings_array = ();
+
+# Check all provided arguments and look for defaults if not provided by user
+determine_args();
+
+# Scan the appropriate files or directories for TRAC macro calls.
+
+if (defined $dir)
+{
+
+    $build = $build . $dir; # default to put at top of string file
+        if($collect)
+        {
+            collect_files($dir);
+        }
+        else
+        {
+            cpp_dir($dir);
+            # Hash the string that have been scanned.
+            %hash_strings_array = hash_strings();
+        }
+}
+else
+{
+    $build = $build . $file; # default to put at top of string file
+
+    if($collect)
+    {
+        assimilate_file($file);
+    }
+    else
+    {
+        # make sure include path includes directory that file is in
+        if($file =~ /^(.+)\/[^\/]+\.C$/)
+        {
+
+            launch_cpp_and_parse($file,$1);
+        }
+        else
+        {
+            # No path in front of file so it has to be local dir
+            launch_cpp_and_parse($file,"./");
+        }
+        # Hash the string that have been scanned.
+        %hash_strings_array = hash_strings();
+    }
+}
+
+# Read the existing string file into memory.
+%string_file_array = read_string_file();
+
+# Write out the new string file. check for collisions of new/old string here
+write_string_file();
+
+print "Hashing Started at $clock\n";
+$clock = `date`;
+print "Hashing Finished at $clock\n";
+
+exit 0;
+
+
+#################################
+#     S U B R O U T I N E S     #
+#################################
+
+#=============================================================================
+#  Enhance usability by figuring out which build env. we are in
+#=============================================================================
+sub determine_args() {
+
+
+    # Find trexhash program
+    # but only if needed (i.e. not in collect mode)
+    if (!$collect) {
+        my $tmp = `which $hash_prog`;
+        chomp $tmp;
+
+        if ($tmp eq '') {
+            print STDOUT "\nWarning: Program trexhash does not exist in path.\n" if $debug;
+            $hash_prog = "./trexhash";
+
+            $tmp = `which $hash_prog`;
+            chomp $tmp;
+            if ($tmp eq '') {
+                print STDOUT "\nError: Unable to find trexhash \n";
+                exit(127);
+            }
+        }
+    }
+
+    # Verify input values.
+    if ((!defined $file) && (!defined $dir)) {
+        if(!($in_sand))
+        {
+            print STDOUT "\nError: No input directory or file provided as input to scan\n";
+            exit(127);
+        }
+
+        # Assume they want sandbox scanned
+        if($collect)
+        {
+            # collect all string files generated by tracepp and merge
+            $dir = "$sandboxbase/obj/";
+        }
+        else
+        {
+            # generate our own string file by pre-compiling all source code
+            $dir = "$sandboxbase/src/";
+        }
+        print STDOUT "\n-f <file> or -d <dir> not found...scanning $dir by default\n\n";
+    }
+
+    if (!defined $string_file)
+    {
+        if ($in_sand)
+        {
+
+            # Copy the current string file from backing build into our sandbox
+            system ("cp $backing/obj/$file_name $sandboxbase/obj/$file_name")
+                if !(-e "$sandboxbase/obj/$file_name");
+
+            $string_file = "$sandboxbase/obj/$file_name";
+        }
+        else
+        {
+            $string_file = "./$file_name";
+        }
+        print STDOUT "-sf <string_file> not specified, using $string_file instead...\n\n" if $debug;
+
+    }
+
+    # Try Creating the string file
+    `touch $string_file`;
+
+    if (! -f $string_file) {
+        print STDOUT "\nError: File $string_file does not exist.  Current directory may not be writable.\n\n";
+        help();
+        exit(127);
+    }
+
+    # Make sure trexStringFile is readable/writeable
+    system("chmod ugo+rw $string_file");
+
+}
+
+#=============================================================================
+#  Launch cpp script and grab input from it looking for trace calls.
+#=============================================================================
+sub launch_cpp_and_parse($$) {
+
+    my ($l_loc, $l_dir) = @_;
+
+    print "Processing file $l_loc\n" if $debug;
+    my $cmd = "/usr/bin/cpp $INCLUDE -I $l_dir $args $l_loc|";
+    print "$cmd\n" if $debug;
+    open(FH,"$cmd")
+        or die ("Cannot open $_:$!,stopped");
+
+    # Read through all lines in the file..
+    my $line = <FH>;
+    while (defined $line)
+    {
+        chop $line; # remove EOL
+        $line =~ s/^\s*//;  # remove unneccesary beginning white space.
+        $line =~ s/\s*$//;  # remove unneccesary ending white space.
+        # Look for lines that are trace macro calls.
+        #if (/(trace_adal_hash)(\()( *)(".+")(,)(\d)/)
+        #if ($line =~ /(.*?)(trace_adal_hash)(\()( *)(".+")(,)(\d)\)+(.*\d.*)/)
+        while($line =~ m/^(.*?)trace_adal_hash\s*\(\s*(("[^"]*"\s*)+),\s*(\d+)\s*\)(.*)$/)
+        {
+            my ($prefix, $strings, $salt, $suffix) = ($1, $2, $4, $5);
+            print STDOUT "$strings $salt\n" if $debug;
+            $strings =~ s/"\s*$//; # remove trailing " and space
+            $strings =~ s/^"//;    # remove leading "
+            $strings =~ s/"\s*"//g;
+            # Check to see if it's contained on a single line, or if we
+            # have to combine lines to get a complete trace call.
+
+            # Save the macro call so it can be hashed later..
+            push (@strings, [$l_loc, $strings, $salt]);
+            $line = $suffix; # check rest of line for a second trace call
+        }
+        my $nextline = <FH>;
+        last if !defined $nextline;
+        # if a trace call is spread over multiple lines we have to add the next
+        # line from the source. the only problem is the definition/declaration
+        # of trace_adal_hash: we have to ignore that. we catch that by requiring
+        # a " after the function name. hopefully nobody writes a comment with
+        # a " after the function declaration ...
+        if ($line =~ /trace_adal_hash.*"/) {
+            $line .= $nextline;
+        } else {
+            $line = $nextline;
+        }
+    }
+    close(FH);
+}
+
+#=============================================================================
+#  run cpp on all files in this directory and return the output
+#=============================================================================
+sub cpp_dir($) {
+
+    my ($l_dir) = @_;
+    my @dir_entry;
+    my $l_entry;
+
+    # Open the directory and read all entry names.
+    opendir ( DH , "$l_dir")
+        or die ("Cannot open $l_dir: $!, stopped");
+
+    print STDOUT "Processing directory $l_dir\n" if $debug;
+    @dir_entry = readdir(DH);
+    closedir(DH);
+
+    while (@dir_entry) {
+        $l_entry = shift(@dir_entry);
+
+        if ($l_dir =~ m"/$") {
+            $l_entry = "$l_dir$l_entry";
+        }
+        else {
+            $l_entry = "$l_dir/$l_entry";
+        }
+
+        # Is the entry a directory?
+        if (-d $l_entry) {
+
+            if($l_entry =~ m"/?([^/]+)$")
+            {
+                # check dir we are going into
+                print "dir = $1\n" if $debug;
+                # should we recurse into this directory.
+                if ($1 =~ m/^(\.\.?|sim[ou]|bldv)$/)
+                {
+                    next; # skip '.', '..' and some fips dirs
+                }
+                cpp_dir($l_entry);
+            }
+            else
+            {
+                # unable to determine name of dir (no / in filename)
+                # should we recurse into this directory.
+                if ($l_entry =~ m/^(\.\.?|sim[ou]|bldv)$/)
+                {
+                    next; # skip '.', '..' and some fips dirs
+                }
+                cpp_dir($l_entry);
+            }
+        }
+        # Is the entry a file?
+        elsif ((-f $l_entry) && ($l_entry =~ m/\.C$/)) {
+            # it's a file so
+            launch_cpp_and_parse($l_entry,$l_dir);
+        }
+        else {
+            # Not a file or directory so ignore it...
+        }
+    }
+}
+
+#=============================================================================
+#  Read in strings from the existing trace string file....
+#=============================================================================
+sub read_string_file() {
+
+    my %o_strings;
+    my ($line) = "";
+    my ($l_hash) = "";
+    my ($l_str) = "";
+    my ($cur_build) = "";
+    my ($l_file) = "";
+
+
+    # Make sure we can open each file.
+    open ( FH , "<$string_file")
+        or die ("Cannot open $_: $!, stopped");
+
+    $line = <FH>;
+
+    print "first line in trexStringFile= $line\n" if $debug;
+
+    if((defined $line) && ($line =~ /^$HEAD_EYE_CATCHER(\d)/))
+    {
+        $version = $1;
+
+        print "version = $version\n" if $debug;
+
+        #Always put latest version in file
+        $line =~ s/^$HEAD_EYE_CATCHER\d/${HEAD_EYE_CATCHER}${HEAD_VER_FLAG}/;
+
+        # Take previous version in file and use it.
+        $build = $line;
+        chomp($build);
+        $line = <FH>;
+
+        while (defined $line) {
+            chomp $line;         # remove EOL
+            if($version eq "1")
+            {
+                ($l_hash, $l_file ,$l_str) = split(/\|\|/, $line);
+            }
+            elsif($version eq "2")
+            {
+                ($l_hash, $l_str ,$l_file) = split(/\|\|/, $line);
+            }
+            else
+            {
+                print "Unknown version of stringfile $version\n";
+                exit(127);
+            }
+            $o_strings{$l_hash} = $l_str . "||" . $l_file;
+            $line = <FH>;
+        }
+
+    }
+    else
+    {   # If there is a file then we are dealing with the first
+        # version of trexStringFile so don't look for file name.
+        if ($debug) {
+            print "version 0 stringfile detected: $string_file\n";
+        }
+
+        # there is a file and it doesn't have a header
+        $version = 0;
+
+        while (defined $line) {
+            chomp $line;         # remove EOL
+            ($l_hash,$l_str) = split(/\|\|/, $line);
+            $o_strings{$l_hash} =$l_str . "||" . "NO FILE";
+            $line = <FH>;
+        }
+    }
+
+    close(FH);
+
+    #Time to look for a building block string file
+    if($BB_STRING_FILE ne "" and $string_file ne $BB_STRING_FILE and -f $BB_STRING_FILE)
+    {
+
+        # Make sure we can open the file.
+        open ( FH , "<$BB_STRING_FILE")
+            or die ("Cannot open $_: $!, stopped");
+
+        $line = <FH>;
+
+        print "first line in BB_StringFile = $line\n" if $debug;
+        if((defined $line) && ($line =~ /^$HEAD_EYE_CATCHER(\d)/))
+        {
+            $version = $1;
+
+            $line = <FH>;
+            while (defined $line)
+            {
+                chop $line;         # remove EOL
+                if($version eq "1")
+                {
+                    ($l_hash, $l_file ,$l_str) = split(/\|\|/, $line);
+                }
+                elsif($version eq "2")
+                {
+                    ($l_hash, $l_str ,$l_file) = split(/\|\|/, $line);
+                }
+                #($l_hash, $l_file ,$l_str) = split(/\|\|/, $line);
+                $o_strings{$l_hash} = $l_str . "||" . $l_file ;
+                $line = <FH>;
+            }
+        }
+        else
+        {
+            print "*** ERROR: BB_StringFile '$BB_STRING_FILE' should always have version!!!\n"
+        }
+
+    }
+    else
+    {
+        print "$BB_STRING_FILE is not available\n" if $debug;
+    }
+    #All files are latest version now.
+    $version = $HEAD_VER_FLAG;
+    return %o_strings;
+}
+
+#=============================================================================
+#  Read in strings from the existing trace string file....
+#=============================================================================
+sub collect_files($) {
+
+    my ($l_dir) = @_;
+    my (@dir_entry);
+    my ($l_entry) = "";
+
+    # Open the directory and read all entry names.
+    opendir ( DH , "$l_dir")
+        or die ("Cannot open $l_dir: $!, stopped");
+
+    print STDOUT "Processing directory $l_dir\n" if $debug;
+    @dir_entry = readdir(DH);
+    closedir(DH);
+
+    while (@dir_entry) {
+        $l_entry = shift(@dir_entry);
+
+        if ($l_dir =~ m"/$") {
+            $l_entry = "$l_dir$l_entry";
+        }
+        else {
+            $l_entry = "$l_dir/$l_entry";
+        }
+
+        # Is the entry a directory?
+        if (-d $l_entry) {
+
+            # should we recurse into this directory.
+            if ($l_entry =~ m/\/(\.\.?|sim[ou]|bldv)$/)
+            {
+                next; # skip '.', '..' and some fips dirs
+            }
+            collect_files($l_entry);
+        }
+        # Is the entry a file?
+        elsif ((-f $l_entry) && ($l_entry =~ m"\.hash$")) {
+            # it's a file so
+            assimilate_file($l_entry);
+        }
+        else {
+            # Not a file or directory so ignore it...
+        }
+    }
+
+}
+
+#=============================================================================
+#  Read in data from file and add to master one
+#=============================================================================
+sub assimilate_file($) {
+
+    my ($l_loc) = @_;
+
+    my (%o_strings);
+    my ($line) = "";
+    my ($l_hash) = "";
+    my ($l_str) = "";
+    my ($l_file) = "";
+
+    # Make sure we can open each file.
+    open ( FH , "<$l_loc")
+        or die ("Cannot open $_: $!, stopped");
+
+    $line = <FH>;
+
+    print "Assimilate: first line in $l_loc = $line" if $debug;
+
+    if((defined $line) && ($line =~ /^$HEAD_EYE_CATCHER(\d)/))
+    {
+        $version = $1;
+        if ($version eq "1") {
+            if ($hash_filename_too) {
+                print "*** ERROR: hash_filename_too (-F) isn't possible with trace version 1\n";
+                print "           please rebuild all .hash files and global trexStringFile\n";
+                print "           version 1 file is '$l_loc'\n";
+                exit(127);
+            }
+        } elsif ($version ne "2") {
+            print "Unknown version of stringfile $version\n";
+            exit(127);
+        }
+
+        $line = <FH>;
+
+
+        while (defined $line) {
+            chop $line;         # remove EOL
+            if($version eq "1")
+            {
+                ($l_hash, $l_file ,$l_str) = split(/\|\|/, $line);
+            }
+            elsif($version eq "2")
+            {
+                ($l_hash, $l_str ,$l_file) = split(/\|\|/, $line);
+            }
+            my $newstring = $l_str . "||" . $l_file;
+            if (exists $hash_strings_array{$l_hash}) {
+                my $hashstr1 = $hash_strings_array{$l_hash};
+                my $hashstr2 = $newstring;
+                if (!$hash_filename_too) {
+                    # hash was made over format string only, remove file name
+                    $hashstr1 =~ s/\|\|.*$//;
+                    $hashstr2 = $l_str;
+                }
+                if ($debug) {
+                    print "a_f: compare $hashstr1\n",
+                          "     vs.     $hashstr2\n";
+                }
+                if ($hashstr1 ne $hashstr2)
+                {
+                    print "*** ERROR: HASH Collision! (a_f)\n",
+                          "    Two different strings have the same hash value ($l_hash)\n",
+                          "    String 1: $hash_strings_array{$l_hash}\n",
+                          "    String 2: $newstring\n";
+                    if ($fail_on_collision) {
+                        exit(1);
+                    }
+                }
+            }
+            $hash_strings_array{$l_hash} = $newstring;
+            $line = <FH>;
+        }
+
+    }
+    else
+    {   # If there is a file then we are dealing with the first
+        # version of trexStringFile so don't look for file name.
+        # these files shouldn't be there anymore. we don't check for collisions here
+        if ($debug) {
+            print "version 0 stringfile detected: $string_file\n";
+        }
+
+        if(defined $line)
+        {
+            # there is a file and it doesn't have a header
+            $version = 0;
+        }
+
+        while (defined $line) {
+            chop $line;         # remove EOL
+            ($l_hash,$l_str) = split(/\|\|/, $line);
+            $hash_strings_array{$l_hash} = $l_str . "||" . "NO FILE";
+            $line = <FH>;
+        }
+    }
+    $version = $HEAD_VER_FLAG;
+    close(FH);
+}
+
+#=============================================================================
+
+#=============================================================================
+sub hash_strings() {
+
+    my ($hash_val, $l_key, $l_hash, %l_hash_strings);
+    my ($line_feed) = chr(10);
+    my ($l_file_name) = "NO FILENAME";
+    print "\nHashing printf strings.\n\n";
+
+    foreach my $str (@strings) {
+        my $printf_string;
+        $l_file_name = $str->[0];
+        $printf_string = $str->[1];
+        $l_key = $str->[2];
+        print "printf_string = $printf_string\n" if $debug;
+        $printf_string =~ s/"\s?"//g; #multi line traces will have extra " in them
+        $printf_string =~ s/`/\\`/g; # excape '
+        $printf_string =~ s/\\n/$line_feed/g; # escape \n
+        if ($hash_filename_too) {
+            $printf_string .= "||" . $l_file_name;
+        }
+
+        # call the hasher.
+        print "$hash_prog \"$printf_string\" $l_key\n" if $debug;
+        $hash_val = `$hash_prog \"$printf_string\" $l_key`;
+        if ($?) {
+            my ($hp_ret, $hp_sig) = ($? >> 8, $? & 127);
+            if ($hp_sig) {
+                print "*** ERROR: $hash_prog died with signal $hp_sig\n";
+            } elsif ($hp_ret) {
+                print "*** ERROR: $hash_prog returned the error $hp_ret\n";
+                if ($hash_val) {
+                    print "   error from $hash_prog:\n$hash_val";
+                }
+            }
+            exit(1);
+        }
+        print "printf_string = $printf_string l_key = $l_key hash val = $hash_val\n" if $debug;
+
+        # undo escaping
+        $printf_string =~ s/$line_feed/\\n/g;
+        $printf_string =~ s/\\`/`/g;
+
+        if (exists $l_hash_strings{$hash_val})
+        {
+            # hash val was found before. check if it's the same string
+            # else we have a hash collision
+            my $l_tmp = $l_hash_strings{$hash_val};
+            if (!$hash_filename_too) {
+                $l_tmp =~ s/\|\|.*$//;
+            }
+            if ($l_tmp ne $printf_string)
+            {
+                print "*** ERROR: HASH Collision! (h_s)\n",
+                      "    Two different strings have the same hash value ($hash_val)\n",
+                      "    String 1: $l_hash_strings{$hash_val}\n",
+                      "    String 2: $printf_string (file $l_file_name)\n";
+                if ($fail_on_collision) {
+                    exit(1);
+                }
+            }
+        }
+        # this will overwrite an old string with a new one if a collision occurred
+        # but we might want to bail out in this case anyway
+        $printf_string = $printf_string . "||" . $l_file_name;
+        $l_hash_strings{$hash_val} = $printf_string;
+    }
+    return %l_hash_strings;
+}
+#=============================================================================
+
+#=============================================================================
+sub write_string_file() {
+
+    my (@keys) = ();
+    my ($l_key) = "";
+
+    # Combine the contents of the existing string file with the trace calls
+    # that we have just hashed.
+    print STDOUT "\nCombining Hash strings...\n\n";
+
+    @keys = keys(%hash_strings_array);
+
+    foreach $l_key (@keys) {
+        my $l_tmp = $hash_strings_array{$l_key}; # freshly collected strings
+        if (exists $string_file_array{$l_key})
+        { # hash exists in list from trexStringFile
+            my $l_tmp2 = $string_file_array{$l_key};
+            if (!$hash_filename_too) {
+                $l_tmp =~ s/\|\|.*$//;
+                $l_tmp2 =~ s/\|\|.*$//;
+            }
+
+            # Check for hash collisions.
+            if ($l_tmp ne $l_tmp2)
+            {
+                print "*** ERROR: HASH Collision! (w_s_f)\n",
+                      "    Two different strings have the same hash value ($l_key)\n",
+                      "    String 1: $hash_strings_array{$l_key}\n",
+                      "    String 2: $string_file_array{$l_key}\n";
+                if ($fail_on_collision) {
+                    exit(1);
+                }
+                # don't fail, write new one
+            }
+        }
+        if($version > 0)
+        {
+            # add/replace the new string to the string_file_array.
+            $string_file_array{$l_key} = $hash_strings_array{$l_key}
+        }
+        else
+        {
+            # old version so only write out format string (not file name to)
+            $string_file_array{$l_key} = $l_tmp;
+        }
+    }
+
+    # Write out the updated string file.
+    print STDOUT "\nWriting updated hash||string file...\n\n";
+
+    @keys = sort(keys(%string_file_array));
+
+    open ( FH , ">$string_file")
+        or die ("Cannot open $_: $!, stopped");
+
+    if($version > 0)
+    {
+        print FH "$build\n"; # only print version if newer then version 0
+    }
+    foreach $l_key (@keys) {
+        print FH "$l_key||$string_file_array{$l_key}\n";
+    }
+    close FH;
+}
+#=============================================================================
+
+#=============================================================================
+#  Display command invokation help for this program...
+#=============================================================================
+sub help() {
+    print << "EOF";
+tracehash.pl - create a trace string file from sources or collect tracepp files
+Usage: tracehash.pl [options]
+    General options:
+      -h   - Print this help text.
+      -v   - Be verbose, tell what's going on (debug output)
+    Operation modes
+      -c   - Collect StringFiles created by tracepp and merge.
+      default - Scan source files for trace calls.
+
+Collect mode: tracehash.pl -c [-vFCS] [-d <dir>] [-s <string_file>]
+              tracehash.pl -c [-vFCS] [-f <file>] [-s <string_file>]
+    Collect string files created by tracepp (.hash) from directory tree at
+    <dir> or read them from string file <file> and write to file
+    <string_file>, adding entries already in this file.
+      -f   - String file to read and write/add to <string_file>.
+      -d   - Start of directory tree to scan for .hash files. Default = .
+      -s   - File with trace strings (and hashes) to read from and write to
+             default = ./trexStringFile
+      -F   - hash is calculated over trace string and source file name,
+             otherwise without source file name
+      -C   - report an error if a hash collisions occurs
+      -S   - don't read global FLD-2.2 string file ($BB_STRING_FILE)
+    If tracehash.pl is called in a FipS build sandbox without -d and -f
+    defaults for the sandbox will be used.
+
+Scan mode: tracehash.pl [-vFCS] [-d <dir>] [-s <string_file>] [ccpopts]
+           tracehash.pl [-vFCS] [-f <file>] [-s <string_file>] [cppopts]
+    Scan all files in directory tree <dir> or scan file <file> and write
+    strings to file <string_file>. Strings already in this file will be merged.
+      -f   - Source file to scan for trace entries.
+      -d   - Source directory to scan for trace entries.
+      -s   - File with trace strings (and hashes) to read from and write to.
+             default = ./trexStringFile
+      -F   - hash for string was build from format string + source file name
+      -C   - report an error if hash collisions occur
+      -S   - don't read global FLD-2.2 string file ($BB_STRING_FILE)
+      All other arguments will be passed verbatim to cpp
+EOF
+}
+#=============================================================================
+
diff --git a/src/tools/tracepp/tracepp.C b/src/tools/tracepp/tracepp.C
new file mode 100755
index 0000000..4ed2b04
--- /dev/null
+++ b/src/tools/tracepp/tracepp.C
@@ -0,0 +1,902 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/tools/tracepp/tracepp.C $                                 */
+/*                                                                        */
+/* OpenPOWER OnChipController Project                                     */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2011,2016                        */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* Licensed under the Apache License, Version 2.0 (the "License");        */
+/* you may not use this file except in compliance with the License.       */
+/* You may obtain a copy of the License at                                */
+/*                                                                        */
+/*     http://www.apache.org/licenses/LICENSE-2.0                         */
+/*                                                                        */
+/* Unless required by applicable law or agreed to in writing, software    */
+/* distributed under the License is distributed on an "AS IS" BASIS,      */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
+/* implied. See the License for the specific language governing           */
+/* permissions and limitations under the License.                         */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+
+/*
+# *** tracepp - Linux trace pre processor
+# this one replaces the trace strings by the corresponding hash value
+
+# *** Usage
+#
+# prepend compiler call with the call of this pre processor, i.e if you have
+#      $(CC) $(CFLAGS) -o $@ $<
+# in your Makefile change it to this:
+#      tracepp $(CC) $(CFLAGS) -o $@ $<
+# tracepp will use "$(CC) -E" to call the C pre processor "cpp".
+# you can set a env var "REALCPP" to the name of a program to select
+# a different programm as cpp
+#
+# tracepp creates a file "$target.hash" with the trace strings and the hash values.
+#
+# to enable debug mode set envvar TRACEPPDEBUG to 1 or give '-d' as first arg
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <time.h>
+#include <fcntl.h>
+#include <map>
+#include <vector>
+#include <unistd.h>
+
+#include <sys/types.h>
+typedef u_int32_t u32 ;
+typedef u_int8_t u8 ;
+#include <jhash.h>
+
+using namespace std;
+
+static string version = "2.0";
+static string macro_version = "1";
+
+static bool debug = false;
+#define dprintf(format, ...) if (debug) { printf(format, ##__VA_ARGS__); fflush(stdout); }
+static map<string,string> hashtab;
+static string hashtype;
+
+static string tmp;
+static string cmd;
+static FILE* CPP = NULL; // pipe from preprocessor
+static FILE* CC = NULL;  // pipe to compiler
+static FILE* DEBUG = NULL;
+static FILE* DEBUGIN = NULL;
+
+//*****************************************************************************
+// replace_substr
+//*****************************************************************************
+void replace_substr(std::string& str, const std::string& oldStr, const std::string& newStr)
+{
+    size_t pos = 0;
+    while((pos = str.find(oldStr, pos)) != std::string::npos)
+    {
+        str.replace(pos, oldStr.length(), newStr);
+        pos += newStr.length();
+    }
+
+}
+
+//*****************************************************************************
+// fileparse
+//*****************************************************************************
+void fileparse(const string& in_str, string& name, string& dir, string& suff)
+{
+    string str(in_str);
+    size_t pos;
+    name = "";
+    dir = "";
+    suff = "";
+    pos = str.find_last_of('.');
+    if (pos != string::npos)
+    {
+        suff = str.substr(pos);
+        str = str.substr(0, pos);
+    }
+    pos = str.find_last_of('/');
+    if (pos != string::npos)
+    {
+        name = str.substr(pos+1);
+        str = str.substr(0, pos+1);
+    }
+    dir = str;
+}
+
+static const size_t TRACE_ADAL_HASH_LEN = 14;
+//*****************************************************************************
+// chop_up_line
+//*****************************************************************************
+bool chop_up_line(string& in_line, string& prefix, string& strings, string& salt, string& suffix)
+{
+    // First see if this line matches the pattern we're looking for
+    // Since this will return false 95%+ of the time this function it called, we do it
+    // before doing any other init for performance reasons.
+    size_t pos = in_line.find("trace_adal_hash");
+    if (pos == string::npos) { return(false); }
+
+    // trace_adal_hash ( "..." ".." "..." , 2 )
+    // regex: PREFIX 'trace_adal_hash' space '(' space STRINGS  space ',' space NUMBER space ')' SUFFIX
+    // STRINGS:  '"' .* '"' space? +
+
+    // Original perl magic incantation:
+    //   while($line =~ m/^(.*?)trace_adal_hash\s*\(\s*((".*?(?<!\\)"\s*)+),\s*(-?\d+)\s*\)(.*)$/) {
+    //      ($prefix, $strings, $salt, $suffix) = ($1, $2, $4, $5);
+    //
+    // Decrypting the magic pattern matching...
+    // (.*?)            => $1 = everything up to the word "trace_adal_hash"
+    // trace_adal_hash  = delimiter
+    // \s*\(\s*         = delimiter = <0-n whitespace chars>, left paren, <0-n whitespace chars>
+    // ((".*?(?<!\\)"\s*)+) => $2 = double-quote, some chars up to last closing double-quote ($3 used for nested regex)
+    // ,\s*             = delimiter = comma followed by some whitespace
+    // (-?\d+)\s*\)(.*) => $4 and $5
+    // $/)             = end of the line input string
+    string line(in_line);
+    prefix = "";
+    strings = "";
+    salt = "";
+    suffix = "";
+    size_t pos1;
+    size_t pos2;
+    size_t pos3;
+
+    pos1 = pos + 15; // pos1 = after "trace_adal_hash"
+    pos2 = line.find("(", pos1);
+    if (pos2 == string::npos) { return(false); }
+    ++pos2;
+    pos3 = line.find("\"", pos2);
+    if (pos3 == string::npos) { return(false); }
+    dprintf("--------\nchop_up_line: Passed basic checks. line= %s\n", line.c_str());
+    dprintf("pos1=%d, pos2=%d, pos3=%d\n", pos1, pos2, pos3);
+    if ((pos1 != (pos2-1)) && (line.find_first_not_of(" \t", pos1, (pos2-pos1)+1) != string::npos)) { return(false); } //non-whitespace?
+    if ((pos2 != pos3) && (line.find_first_not_of(" \t", pos2, (pos3-pos2)) != string::npos)) { return(false); } //non-whitespace?
+
+    // Get the prefix data
+    dprintf(">chop_up_line(\"%s\",...)\n", line.c_str());
+    prefix = line.substr(0, pos);
+    line = line.substr(pos + TRACE_ADAL_HASH_LEN);
+    dprintf("    prefix=\"%s\"\n", prefix.c_str());
+
+    // Get the strings and join/fix them: Store all strings between paired double-quotes up to the
+    // first comma not inside a string
+    pos = line.find_first_of('(');
+    if (pos == string::npos) { return(false); }
+    line = line.substr(pos + 1);
+    strings = "";
+    while(!line.empty())
+    {
+        pos = line.find_first_of(',');
+        pos1 = line.find_first_of('"');
+        if ((pos1 == string::npos) || ((pos != string::npos) && (pos < pos1))) { break; } // found comma before next quote
+        pos2 = line.find_first_of('"', (pos1+1));
+        if (pos2 == string::npos) { return(false); } // unbalanced quotes!
+        while(line[pos2-1] == '\\') // skip escaped quotes in the string (they're not the ending quote)
+        {
+            pos2 = line.find_first_of('"', (pos2+1));
+            if (pos2 == string::npos) { return(false); } // unbalanced quotes!
+        }
+        if (!strings.empty()) { strings += " "; }
+        strings += line.substr(pos1, (pos2-pos1)+1);
+        line = line.substr(pos2+1);
+    }
+    replace_substr(strings, "\" \"", "");
+    replace_substr(strings, "\\\"", "ESCAPEDQUOTE");
+    replace_substr(strings, "\"", "");
+    replace_substr(strings, "ESCAPEDQUOTE", "\"");
+    // Remove trailing whitespace
+    pos = strings.find_last_not_of(" \t\n");
+    if ((pos != string::npos) && (pos < (strings.length()-1)))
+    {
+        strings = strings.substr(0, pos+1);
+    }
+
+    dprintf("    strings>%s<\n", strings.c_str());
+
+    // Get the salt
+    pos = line.find(",");
+    if (pos != string::npos) { line = line.substr(pos+1); }
+    pos = line.find_first_of(')');
+    if (pos == string::npos) { return(false); }
+    salt = line.substr(0, pos);
+    line = line.substr(pos+1);
+    //dprintf("    salt=\"%s\"\n", salt.c_str());
+    pos = salt.find_first_not_of(" \t\n");
+    if (pos == string::npos) { return(false); }
+    salt = salt.substr(pos);
+    pos = salt.find_last_not_of(" \t\n");
+    if (pos == string::npos) { return(false); }
+    salt = salt.substr(0, pos+1);
+    dprintf("    salt=\"%s\"\n", salt.c_str());
+
+    // Get the suffix (i.e. the rest)
+    suffix = line;
+    if (suffix[suffix.length()-1] == '\n') { suffix = suffix.substr(0, suffix.length()-1); }
+    dprintf("    suffix=\"%s\"\n<chop_up_line() returning true\n", suffix.c_str());
+
+    return(true);
+}
+
+//*****************************************************************************
+// get_format_string
+//*****************************************************************************
+int get_format_string(const string& in_str, string& format)
+{
+    int format_salt = 0;
+    size_t pos;
+    size_t pos_end;
+    string str(in_str);
+    // (@format_param) = ($strings =~ /(%[#0\- +'I]*\d*(?:\.\d*)?[hlLqjzt]*[diouxXeEfFgGaAcsCSpn])/g);
+    // $format = join(',', @format_param);
+    // Decrypting the regular expression magic...
+    // (%[#0\- +'I]*\d*(?:\.\d*)?[hlLqjzt]*[diouxXeEfFgGaAcsCSpn])
+
+    format = "";
+    while(!str.empty())
+    {
+        pos = str.find("%");
+        if (pos == string::npos) { break; }
+        if (pos == (str.length()-1)) { break; } // last char in string?  just skip it
+        if (str[pos+1] == '%') // double percent sign?  just skip first one
+        {
+            str = str.substr(pos+1);
+            continue;
+        }
+        pos_end = str.find_first_of("cdieEfgGosuxXpn", pos); // find formatting specifier
+        if (pos_end == string::npos)
+        {
+            fprintf(stderr, "ERROR: tracepp could not parse trace formatting string \"%s\" in \"%s\"\n", str.c_str(), in_str.c_str());
+            break;
+        }
+
+        if (!format.empty())
+            format += ",";
+        format += str.substr(pos, (pos_end-pos)+1);
+        ++format_salt;
+
+        str = str.substr(pos_end+1);
+    }
+    // Correct for escaped percent signs
+    string temp_str(in_str);
+    while((pos = temp_str.find("%%")) != string::npos)
+    {
+        if (pos < (temp_str.length()-2)) // Not the last thing in the string?
+        {
+            dprintf("    decrementing salt value %d\n", format_salt);
+            --format_salt;
+            temp_str = temp_str.substr(pos+2);
+        }
+        else
+        {
+            temp_str = "";
+        }
+    }
+
+    return(format_salt);
+}
+
+#define BUF_SIZE 40
+//*****************************************************************************
+// get_hash
+//*****************************************************************************
+void get_hash(const string& i_str, const unsigned int salt_num, string& hash)
+{
+    string str(i_str);
+    unsigned int hash_num = 0;
+    char buf[BUF_SIZE];
+
+    hash = "";
+    dprintf(">get_hash(\"%s\",%d)\n", str.c_str(), salt_num);
+
+    // Call jhash function to get the hash value
+    hash_num = jhash((void*)str.c_str(), str.length(), salt_num);
+    dprintf("jhash() returned: %u\n", hash_num);
+    sprintf(buf, "%u", hash_num);
+    hash = buf;
+
+    // validate the hash value
+    size_t pos = hash.find_first_not_of("0123456789");
+    if (pos != string::npos)
+    {
+        fprintf(stderr, "trexhash error: %s\n", hash.c_str());
+        fprintf(stderr, "for call <<%s>>\n", cmd.c_str());
+        exit(1);
+    }
+
+    // If hash is empty, use the sum of the ord values in the original string
+    if ((hash == "")||(hash == "0"))
+    {
+        unsigned int len = str.length();
+        unsigned int hash_num = 0;
+        //unsigned char conv_buf[2] = { '\0', '\0' };
+        u_int8_t conv_num;
+        for (unsigned int i=0; i < len; ++i)
+        {
+            //conv_buf[0] = str[i];
+            conv_num = (u_int8_t)str[i];
+            hash_num += (unsigned int)conv_num;
+        }
+    }
+    dprintf("<get_hash(\"%s\",%d) returned hash: %s\n", str.c_str(), salt_num, hash.c_str());
+}
+
+//*****************************************************************************
+// parse_line
+//*****************************************************************************
+void parse_line(map<string,string>& rhash, string& line, string& out_line)
+{
+    // NOTE: "line" arg may get modified by this function!  Caller must not assume it's unchanged.
+    string format;
+    string prefix;
+    string strings;
+    string tmp;
+    string salt;
+    string hash;
+    int salt_num;
+    int format_salt;
+    string suffix;
+    string write_all_suffix;
+    size_t pos;
+
+    out_line = "";
+    // trace_adal_hash ( "..." ".." "..." , 2 )
+    // regex: PREFIX 'trace_adal_hash' space '(' space STRINGS  space ',' space NUMBER space ')' SUFFIX
+    // STRINGS:  '"' .* '"' space? +
+    //while($line =~ m/^(.*?)trace_adal_hash\s*\(\s*((".*?(?<!\\)"\s*)+),\s*(-?\d+)\s*\)(.*)$/) {
+    // Attempt to approximate the above amazing perl regex...
+    while( chop_up_line(line, prefix, strings, salt, suffix) )
+    {
+        //dprintf("\n\nprefix = %s\nstrings = %s\nsalt = %s\nsuffix = %s\n",
+        // prefix.c_str(), strings.c_str(), salt.c_str(), suffix.c_str());
+        // is this a trace_adal_write_all call?
+        pos = prefix.find("trace_adal_write_all");
+        if (pos != string::npos)
+        {
+            // yes. replace trace_adal_hash with hash value and reduced format string
+            format_salt = get_format_string(strings, format);
+            // reduced format string will be added after hash value
+            write_all_suffix = ",\" ";
+            write_all_suffix += format;
+            write_all_suffix += "\"";
+
+            if (!salt.empty())
+            {
+                salt_num = atoi(salt.c_str());
+            }
+            else
+            {
+                salt_num = -1;
+            }
+
+            if (salt_num == -1)
+            {
+                salt_num = format_salt;
+            }
+            else if (salt_num != format_salt)
+            {
+                fprintf(stderr, "ERROR: printf mismatch in '%s': TRACE says %d, format says %d args\n",
+                        line.c_str(), salt_num, format_salt);
+            }
+        }
+        else
+        {
+            write_all_suffix = "";
+            salt_num = atoi(salt.c_str());
+        }
+
+        // get the trex hash value for the strings
+        get_hash(strings, salt_num, hash);
+
+        // check for duplicate and store the mapping
+        if ((rhash.find(hash) != rhash.end()) && (rhash[hash] != strings))
+        {
+            fprintf(stderr, "hash collision: two different strings give the same hash value '%s'\n", hash.c_str());
+            fprintf(stderr, "%s\n%s\n", strings.c_str(), rhash[hash].c_str());
+            return;
+        }
+        rhash[hash] = strings;
+
+        // add the modified line to the output
+        tmp = prefix;
+        tmp += "((";
+        tmp += hashtype;
+        tmp += ") ";
+        tmp += hash;
+        tmp += "U)";
+        tmp += write_all_suffix;
+        out_line += tmp;
+        dprintf("changed call: %s...\n", tmp.c_str());
+        line = suffix;
+    }
+    out_line += line;
+    if (out_line[out_line.length()-1] != '\n')
+        out_line += "\n";
+}
+
+//*****************************************************************************
+//                                 main
+//*****************************************************************************
+int main(int argc, char** argv)
+{
+    char* p_env = getenv("TRACEPPDEBUG");
+    if (p_env)
+        debug = true;
+
+
+    int argi = 1;
+    string arg;
+    string optarg;
+    if (argc > 1) arg = argv[1];
+    if ((argc < 2) || (arg == "-h"))
+    {
+        fprintf(stderr, "usage: %s realcompiler compileroptions -o target source\n", argv[0]);
+        exit(9);
+    }
+    string realcc(argv[argi++]);
+    string cctype("c++");
+    bool optx_found = false;
+
+    if (realcc == "-d")
+    {
+        debug = true;
+        realcc = argv[argi++];
+    }
+
+    // wait until -d options is handled before checking $debug
+    dprintf("tracepp version %s - API/macro version %s\n", version.c_str(), macro_version.c_str());
+
+    p_env = getenv("REALCPP");
+    string realcpp;
+    if (p_env)
+        realcpp = p_env;
+    if (realcpp.empty())
+    {
+        dprintf("cannot find cpp, using <realcompiler> -E\n");
+        realcpp = realcc;
+        realcpp += " -E";
+    }
+    dprintf("realcpp is %s\n", realcpp.c_str());
+
+    //------------------------------------------------------------------------------
+    // parse all the arguments
+    //------------------------------------------------------------------------------
+    string source;
+    string object;
+    vector<string> ccopts;
+    vector<string> cppopts;
+    bool dodeps = false;
+    string depfile;
+    string pfx;
+    string sfx;
+    int origargi = argi;
+    for( ; argi < argc; ++argi)
+    {
+        arg = argv[argi];
+        dprintf("Processing argv[%d]: \"%s\"\n", argi, arg.c_str());
+        if (arg.length() > 2)
+        {
+            pfx = arg.substr(0,2);
+            sfx = arg.substr(arg.length()-2);
+        }
+        else
+        {
+            pfx = arg;
+            sfx = arg;
+        }
+        dprintf("   pfx: \"%s\"    sfx: \"%s\"\n", pfx.c_str(), sfx.c_str());
+
+        if (pfx == "-o")
+        {
+            if (! object.empty())
+            {
+                fprintf(stderr, "two -o options, aborting\n");
+                exit(1);
+            }
+            if (arg.length() > 2)
+            {
+                object = sfx;
+            }
+            else
+            {
+                object = argv[++argi];
+            }
+            dprintf("object is now %s\n", object.c_str());
+        }
+        else if (arg == "-c")
+        {
+            // don't call cpp with -c, this is for the compiler
+            ccopts.push_back(arg);
+            dprintf("found -c option\n");
+        }
+        else if (pfx == "-l")
+        {
+            // cpp doesn't need library arguments
+            cppopts.push_back(arg);
+        }
+        else if (pfx == "-i")
+        {
+            // option takes an argument, handle it too
+            optarg = argv[argi++];
+            ccopts.push_back(arg);
+            ccopts.push_back(optarg);
+            cppopts.push_back(arg);
+            cppopts.push_back(optarg);
+            dprintf("found option '%s %s'\n", arg.c_str(), optarg.c_str());
+        }
+        else if ((arg == "-L") ||
+                 (arg == "-I") ||
+                 (arg == "-x") ||
+                 (arg == "-b") ||
+                 (arg == "-B") ||
+                 (arg == "-V") ||
+                 (arg == "-D") ||
+                 (arg == "--param") ||
+                 (arg == "-MQ") ||
+                 (arg == "-MT"))
+        {
+            // option takes an argument, handle it too
+            optarg = argv[argi++];
+            ccopts.push_back(arg);
+            ccopts.push_back(optarg);
+            cppopts.push_back(arg);
+            cppopts.push_back(optarg);
+            dprintf("found option '%s %s'\n", arg.c_str(), optarg.c_str());
+            if (arg == "-x")
+            {
+                // option x sets the language - c or c++
+                if ((optarg != "c") && (optarg != "c++"))
+                {
+                    fprintf(stderr, "cannot process language '%s', aborting\n", optarg.c_str());
+                    exit(1);
+                }
+                cctype = optarg;
+                optx_found = true;
+            }
+        }
+        else if ((arg == "-MD")||(arg == "-MG"))
+        {
+            // gen deps
+            dodeps = true;
+            dprintf("found %s, creating dependencies\n", arg.c_str());
+        }
+        else if (arg == "-MF")
+        {
+            // set dependencies file
+            depfile = argv[argi++];
+            dprintf("set dependencies file to '%s'\n", depfile.c_str());
+        }
+        else if (arg[0] == '-')
+        {
+            // arg starts with - so it's an option
+            ccopts.push_back(arg);
+            cppopts.push_back(arg);
+            dprintf("found option '%s'\n", arg.c_str());
+        }
+        else if ((sfx == ".a") ||
+                 (sfx == ".o"))
+        {
+            // an object or archive, ignore this but give it to cc
+            ccopts.push_back(arg);
+            dprintf("found object/archive '%s'\n", arg.c_str());
+        }
+        else if ((sfx == ".c") ||
+                 (sfx == ".C") ||
+                 (arg.substr(arg.length()-4) == ".cpp") ||
+                 (arg.substr(arg.length()-4) == ".cxx"))
+        {
+            // the source file(s). we should only get one
+            if (!source.empty())
+            {
+                fprintf(stderr, "don't know to handle two source files, aborting\n");
+                exit(1);
+            }
+            source = arg;
+            // put the - (for read-from-stdin) where the source file was
+            // (order is important!)
+            ccopts.push_back("-");
+            dprintf("found source file %s\n", source.c_str());
+        }
+        else if (access(arg.c_str(), F_OK))
+        {
+            // option but not a file, an unknown option?
+            ccopts.push_back(arg);
+            cppopts.push_back(arg);
+            dprintf("found unknown option '%s'\n", arg.c_str());
+        }
+    }
+
+    //------------------------------------------------------------------------------
+    // set other parameters based on arguments specified
+    //------------------------------------------------------------------------------
+    if (source.empty())
+    {
+        // this might be a call to link a program instead of compile a source (or asm source)
+        dprintf("NOTME: starting as cc '%s ...'\n", realcc.c_str());
+        execvp(realcc.c_str(), &(argv[origargi]));
+        fprintf(stderr, "ERROR: returned from execvp() call to run %s\n", realcc.c_str());
+    }
+    if (object.empty())
+    {
+        dprintf("no object file given, default to source name\n");
+        // gcc builds object name from source name if no -o given, replacing
+        // suffix with .o. The file is placed in the current directory,
+        // not in the source directory!
+        string n;
+        string d;
+        string s;
+        fileparse(source, n, d, s);
+        if (!n.empty() && !s.empty())
+        {
+            object = n + ".o";
+            dprintf("tracpp: guessing object name %s\n", object.c_str());
+            dprintf("        from source name     %s\n", source.c_str());
+        }
+        else
+        {
+            fprintf(stderr, "Unable to determine Source File Name\n");
+            exit(1);;
+        }
+    }
+
+    // set value of trace hash according to language
+    // check source file extension if no explicit -x option given
+    if (!optx_found)
+    {
+        if (realcc.find("g++") != string::npos)
+        {
+            dprintf("compiler language: C++ (from compiler name)\n");
+            cctype = "c++";
+        }
+        else
+        {
+            if (source.substr(source.length()-2) == ".c")
+            {
+                dprintf("compiler language: C (from source file extension)\n");
+                cctype = "c";
+            }
+            else
+            {
+                dprintf("compiler language: C++ (default)\n");
+                cctype = "c++";
+            }
+        }
+    }
+    else
+    {
+        dprintf("compiler language: %s (from option '-x')\n", cctype.c_str());
+    }
+
+    if (cctype == "c")
+    {
+        hashtype = "unsigned long";
+    }
+    else
+    {
+        hashtype = "trace_hash_val";
+    }
+    // define TRAC_TRACEPP for macros
+    tmp = "-DTRAC_TRACEPP -DTRAC_PPVER=";
+    tmp += macro_version;
+    cppopts.push_back(tmp);
+    if (dodeps)
+    {
+        if (depfile.empty())
+        {
+            if ((p_env = getenv("DEPENDENCIES_OUTPUT")) != NULL)
+            {
+                depfile = p_env;
+            }
+            else if ((p_env = getenv("SUNPRO_DEPENDENCIES")) != NULL)
+            {
+                depfile = p_env;
+            }
+            else
+            {
+                depfile = object;
+                if (depfile.substr(depfile.length()-2) == ".o")
+                {
+                    depfile = depfile.substr(0, depfile.length()-2);
+                    depfile += ".d";
+                }
+            }
+        }
+        tmp = "-MD -MF ";
+        tmp += depfile;
+        cppopts.push_back(tmp);
+    }
+
+    //------------------------------------------------------------------------------
+    // start cpp
+    //------------------------------------------------------------------------------
+    cmd = realcpp;
+    for(vector<string>::iterator p = cppopts.begin(); p != cppopts.end(); ++p)
+    {
+        cmd += " ";
+        cmd += *p;
+    }
+    cmd += " ";
+    cmd += source;
+    cmd += " -o-";
+    dprintf("starting as cpp '%s'\n", cmd.c_str());
+    CPP = popen(cmd.c_str(), "r");
+    if (CPP == NULL)
+    {
+        fprintf(stderr, "cannot start cpp '%s'\n", realcpp.c_str());
+        perror("");
+        exit(1);
+    }
+
+    //------------------------------------------------------------------------------
+    // start cc. manually set language as source file extension not available to cc
+    //------------------------------------------------------------------------------
+    string type_str = "";
+    if (!optx_found)
+    {
+        // no option -x given by caller, set manually
+        type_str = "-x ";
+        type_str += cctype;
+    }
+    cmd = realcc;
+    cmd += " ";
+    cmd += type_str;
+    for(vector<string>::iterator p = ccopts.begin(); p != ccopts.end(); ++p)
+    {
+        cmd += " ";
+        cmd += *p;
+    }
+    cmd += " -o ";
+    cmd += object;
+    dprintf("starting as cc '%s'\n", cmd.c_str());
+    CC = popen(cmd.c_str(), "w");
+    if (CC == NULL)
+    {
+        fprintf(stderr, "cannot start cc '%s'\n", realcc.c_str());
+        perror("");
+        exit(1);
+    }
+
+    string modifiedfile;
+    string unmodifiedfile;
+    if (debug)
+    {
+        modifiedfile = object + ".debug";
+        DEBUG = fopen(modifiedfile.c_str(), "w");
+        if (DEBUG == NULL)
+        {
+            string msg = "cannot open file ";
+            msg += modifiedfile;
+            perror(msg.c_str());
+            modifiedfile = "";
+        }
+        else
+        {
+            fprintf(stderr, "writing preprocessed source to %s\n", modifiedfile.c_str());
+        }
+        unmodifiedfile = object + ".debug_in";
+        DEBUGIN = fopen(unmodifiedfile.c_str(), "w");
+        if (DEBUGIN == NULL)
+        {
+            string msg = "cannot open file ";
+            msg += unmodifiedfile;
+            perror(msg.c_str());
+            unmodifiedfile = "";
+        }
+        else
+        {
+            fprintf(stderr, "writing unprocessed source to %s\n", unmodifiedfile.c_str());
+        }
+    }
+
+    string oldline;
+    string newline;
+    static const int MAX_BUFFER = 51200;
+    char buf[MAX_BUFFER];
+    while (!feof(CPP))
+    {
+        if (fgets(buf, MAX_BUFFER, CPP) != NULL)
+        {
+            oldline = buf;
+            if (DEBUGIN) { fprintf(DEBUGIN, "%s", oldline.c_str()); }
+            parse_line(hashtab, oldline, newline);
+            //#print "oldline = $oldline";
+            //#print "newline = $newline";
+            if (newline.empty())
+            {
+                fprintf(stderr, "hash error in/with file %s\n", source.c_str());
+                exit(1);
+            }
+            //#print "newline = $newline\n";
+            fprintf(CC, "%s", newline.c_str());
+            if (DEBUG) { fprintf(DEBUG, "%s", newline.c_str()); }
+        }
+    }
+    if (DEBUG) { fclose(DEBUG); }
+    if (DEBUGIN) { fclose(DEBUGIN); }
+    int cmd_rc = pclose(CPP);
+    if (cmd_rc)
+    {
+        fprintf(stderr, "error from cpp\n");
+        if (cmd_rc & 127)
+        {
+            fprintf(stderr, "cpp got signal %d\n", (cmd_rc & 127));
+            exit(1);
+        }
+        else if (cmd_rc >> 8)
+        {
+            fprintf(stderr, "cpp returned %d\n", (cmd_rc >> 8));
+            exit(cmd_rc >> 8);
+        }
+    }
+    cmd_rc = pclose(CC);
+    if (cmd_rc)
+    {
+        fprintf(stderr, "error from cc\n");
+        if (cmd_rc & 127)
+        {
+            fprintf(stderr, "cc got signal %d\n", (cmd_rc & 127));
+            exit(1);
+        }
+        else if (cmd_rc >> 8)
+        {
+            fprintf(stderr, "cc returned %d\n", (cmd_rc >> 8));
+            exit(cmd_rc >> 8);
+        }
+    }
+
+    if (!hashtab.empty())
+    {
+        string stringfile = object;
+        stringfile += ".hash";
+        // open trace string file
+        FILE* TRC = fopen(stringfile.c_str(), "w");
+        if (TRC == NULL)
+        {
+            fprintf(stderr, "cannot write trace string file '%s'\n", stringfile.c_str());
+            exit(1);
+        }
+        dprintf("Writing to file %s\n", stringfile.c_str());
+
+        string pwd;
+        FILE* PWD = popen("pwd", "r");
+        fgets(buf, MAX_BUFFER, PWD);
+        pwd = buf;
+        pclose(PWD);
+        time_t tt = time(NULL);
+        sprintf(buf, "%s", asctime(localtime(&tt)));
+        buf[strlen(buf)-1] = '\0'; // chop off extra newline
+        fprintf(TRC, "#FSP_TRACE_v2|||%s|||BUILD:%s", buf, pwd.c_str());
+
+        string srch_str = "||";
+        srch_str += source;
+        int srch_str_len = srch_str.length();
+        size_t pos;
+        for(map<string,string>::iterator p = hashtab.begin(); p != hashtab.end(); ++p)
+        {
+            pos = (p->second).find(srch_str);
+            if ((pos != string::npos) && ((pos + srch_str_len) == (p->second).length()))
+            {
+                // source file name is already part of the string
+                fprintf(TRC, "%s||%s\n", (p->first).c_str(), (p->second).c_str());
+            }
+            else
+            {
+                fprintf(TRC, "%s||%s||%s\n", (p->first).c_str(), (p->second).c_str(), source.c_str());
+            }
+            //#print TRC "$key||$source||$hashtab{$key}\n";
+        }
+        fclose(TRC);
+    }
+    else
+    {
+        dprintf("No trace calls/strings found, not writing hash file\n");
+    }
+} // end main