Fixes for StackwalkerAPI on BlueGene

Turns off gap parsing for Dyninst's runtime library and removes compiler warnings

x86 fix

isReturnInst is relevant only in power since a return instruction (blr) can
be a real return or indirect jump using LR. For x86, if the instruction
category is ReturnInsn, is it HAS to be a return. Hence, it is the same
as isReturn function.

Fix for vxWorks platform.

Older 4.x versions of GCC cannot compare const_iters and regular iters.

Optimize the x86/x86_64 stack alignment sequence.
 - Only align the stack if we generate a function call or save the FP state.
 - If we must align the stack, only preserve the flags if they are live.

x86 build fix for previous commit

powerpc rewriter commit

This commit implements more accurate heuristics for parsing
powerpc jump tables using backward dataflow graph analysis.

This commit also implements heuristics and backward slicing
to determine if a blr instruction in a powerpc binary,
is a return or a jump table. This is specially relevant to BlueGene binaries.
To do slicing, an instruction adapter is always constructed/associated
with a specific block.

Force FP saves

As per user request, we are adding a force FP save option.
This will force FP registers to be saved. This is necessary because
right now, even if saveFP is set, analysis may incorrectly determine
no FP is ised and hence not save FP registers. This happens if
the instrumentation calls a function using FP in the rewriter case.
forceFPSave interface will not be published - since we hope to fix this for
the next release.

Enable powerpc traps.

1)This will cause sigtraps to be used for long jumps or when we do
  have free registers.
2)This will cause trap instructions to be used in placed of
  relocated instructions. This makes life easy for debugging when
 we have jumps into relocated code.

powerpc instruction semantics

Adding more instructions to powerpc semantics set.

Slicing changes

Slicing had a bug in labeling edges in the backward slicing case.
The edge from the instruction at which backward slicing
is applied, was labeled with the output of the instruction. Instead we
should create an edge for each of the inputs to the instruction (since
it is backward slicing) and label them based on the input.

Minor commit

This commit includes many small changes:
1) Added semantics for si, subfz and ora powerpc instructions
2) Removed printf from dataflow Visitor
3) Added check to make sure we are not opening a
   rewritten binary using openFile. Opening rewritten file
   will cause symtabAPI and and parsing to fail.
4) Symtab was adding a new library dependency using the full
   path of the library. We should only add the library name
   without full path, so that LD_LIBRRAY_PATH of the user's
   environment will determine which library to use. This is
   very critical in bluegene type environment where the
   backend does not have access to the whole filesystem.

Make symlinks local to the install directory, rather than including build residue.

Make destination directories have absolute paths so that we don't screw up symlinks.

Remove dead code (save_the_world, #if 0).

A few more fixes for RTlib naming.

Add absolute conditionals and blrl to ppc semantics.

Add component versioning information to all components & filenames.

Changes for library versioning; verified on linux/x86_64 and AIX

Add --exe option for runhunt mode--allows runhunt to be used on a shared library driven by an un-rewritten executable.

Comment out debugging code in ProcControlAPI.

Merge branch 'master' into devel

BPatch interface to specify non-returning functions

Remove cycle edges before populating expansion worklist. Expand from all
nodes, rather than just entryNodes.

Remove self-loops from slices.

Eliminate spurious `thunk function' detection on x86

A `thunk function' is one that contains exactly two instructions:

mov (%esp),<a register>
ret

This construct is used in position independent code to retrieve
the program counter---see for example the __i686.get_pc_thunk.*
functions in glibc. Previously, any function that had a mov
instruction that referenced the stack pointer followed by a return
would be treated as a thunk. This commit properly checks for a
zero-offset dereference of the stack pointer.

Optimize order of slice expansion

The order that slice nodes are visited in slice -> AST expansion matters
quite a bit; bad visitation order can lead to a great deal of extra work
being done as nodes are repeatedly visited to fill in partially expanded
ASTS. Because cycles in the slice DAG are removed prior to expansion,
an optimal ordering is possible. This commit implements that ordering. It
also correctly avoids traversing the `skip edges' that are removed to
break cycles in all instances of edge enumeration.

Improves efficiency of the slicing algorithm

The previous slicing algorithm searched the control flow graph in a
sub-optimal fashion, leading to complexity that was quadratic in the
best case of CFGs that are chains (linear control flow without
branches). This commit introduces a recursive slicing algorithm that
avoids this structural problem.

Fixes for bug 1081, bug 1104 (fork test bugs)

Both of these bugs were caused by a combination of OS bugs and our fork tests
using mutatees where the parent can exit before the child and both the child
and parent are short lived. Both of the OS bugs were reproduced using test
programs separate from Dyninst, so I am confident we are indeed observing
kernel bugs.

This commit, in addition to fixes for these bugs, removes the extra continues
in our test_fork_* tests that were added to avoid leaving around a bunch of
stopped processes when the nightlies ran.

Bug 1081:

We were seeing the fork tests leave around stopped mutatees on AIX. This bug
was being triggered by our soft breakpoint mechanism in the RT library that has
a process send itself a SIGSTOP. The following chain of events triggers the
bug:

1) The parent forks a child
2) The child sends itself a SIGSTOP
3) Dyninst continues both the parent and child
4) The parent exits before the child
5) The child exits almost immediately after being forked
6) Dyninst sees the pre-exit stop of the child and continues it
7) After continue the child is delivered a SIGSTOP by the OS

We originally used the soft breakpoint mechanism because we could not rely on
AIX to attach to and stop a child after fork. This was a bug on version 5.2 of
AIX. Since we have decided to no longer support AIX 5.2, we can rely on the OS
to automatically mark forked processes as being traced by Dyninst. Ideally, we
would want to stop both the parent and child at the exit of fork to initiate
some updates in the RT library using the OS provided mechanism for this. Due to
some probably more OS bugs, this cannot be done.

AIX 5.3 still exhibits some odd behavior where LWPs cannot be modified
on syscall entry/exit. An existing workaround for this is to set a trap at
the exit of the system call. This is done by reading registers and walking
the stack (if necessary). However, for the child at the exit of fork, the
values read from the registers are unreliable.

Working around all these bugs, the solution becomes to use a SIGTRAP instead of
a SIGSTOP in our soft breakpoint mechansim.

Bug 1104:

For test4_2, we were seeing a race where the exit callback of the child was not
being delivered, causing the test to fail. This bug in Dyninst was being
triggered by another kernel bug where if the parent exited before the child
entered userland for the first time, the child process would never execute.

In this scenario, Dyninst would observe that the child process disappeared and
generate an approriate event. On UNIX platforms, we however don't deliver
callbacks on a normal process exit; we deliver them at the entrance to the exit
system call when the process' address space is still around.  In this case, the
child doesn't hit our pre-exit instrumentation and we therefore don't deliver
the callback.

The fix is to check whether a callback has been attempted to be delivered when
we receive the process exit event and deliver the callback if it hasn't been
delivered yet. Additionally, the type of callback delivered is the same as if
the process had exited due to a signal because the process' address space is
not around anymore. When the kernel bug occurs, this would still cause the
test to fail so I have modified the mutatee's parent to wait for the child.

Force stack alignment on x86/x86_64 platforms.

Both x86 and x86_64 platforms require an aligned stack pointer at certain
points of execution.  This commit introduces a preamble in our state saving
code to forcably align the stack pointer.

Care is also taken to ensure the stack is aligned before we generate a
function call on x86_64.  Similar functionality may be needed for x86
in the future.

Added missing instruction entries to IAPI string map

Fix for non-cap_registers platforms

Added optional parameter in getRegisters to return SPRs

Added missing header files

Merge branch 'master' into devel

Fix bug 1144, Register liveness on Power

Fixes IBSTree::successor bug that could trigger after range removal

Range removal introduces the possibility of nodes in the tree
that have empty equals sets, meaning that successor has to be
able to do a full depth-first search, since we never remove
nodes from the tree.

Fix segfault in symbolic expansion due to inconsistent operator<

Cleanup.

Merge branch 'master' of ssh://git.dyninst.org/pub/dyninst

Changed backward slicing to not re-trigger parsing during slice.
Checking interprocedural edges to follow is now moved into the
followCallBackward predicate and can be triggered by a user as necessary.

Fixes BPatch_basicBlockLoop::hasAncestor

BPatch_basicBlockLoop::hasAncestor(otherloop) queries were breaking for complicated loops.
hasAncestor works by traversing a linked list of parents, but this method can fail if a loop
is contained by multiple equivalent loops defined by distinct back edges.
I switched the hasAncestor implementation to do a lookup in the (already existing)
BPatch_basicBlockLoop::containedLoops set.

Merge branch 'master' of git.dyninst.org:/pub/dyninst

Prevent duplication of cached call edges

ParseAPI::Functions cache call edges for rapid lookup. Incremental parsing
or updating of a parsed function could lead to such edges being duplicated.

Windows build fix

Enable Windows register liveness.

Merge branch 'master' of ssh://git.dyninst.org/pub/dyninst

Stackwalker documentation corrections

Use provided names for PLT functions, if available.

During parsing, calls through the PLT lead to creation of functions
for the PLT entry stubs. These functions were getting the standard
targ* names we give to recursively discovered functions, which names
can be highly annoying when you KNOW that the real name of the PLT
entry in question exists RIGHT THERE in the symbol table. This commit
does the Right Thing.

Added stackwalker documentation to the repository

Small fix for vxWorks platform.

Older 4.x versions of GCC cannot compare const_iters and non-const_iters.

shouldRunTest(), contrary to its name, is not idempotent.  Reverting "fix" in this area.

Merge branch 'master' of git.dyninst.org:/pub/dyninst

Handle SymEval cases where there are overlapping identical inputs.

Fix problem in mis-identifying cycles in slices.

ppc32_linux fix

runTests on ppc32_linux was spinning and spewing
kill signal messages while running the
nightly testsuite. This was
due to a bad while loop which was
running forever. This led to a timeout in
our testsuite. Fixed with iterators.
This should fix build and run
problems in bruckner.

ParseAPI manual update

Implements findMain() for ppc32-Linux.

The location of main is stored in a data structure passed to
__libc_start_main in glibc. The _start code linked at the beginning
of the text section computes the address of this data structure;
this patch uses slicing and SymEval to evaluate this computation
and extract the address of main from the startup structure.

Avoid deadlock when recursively parsing tail calls, while ensuring that
the return status of the [tail-]calling function is properly updated.

Also use a more efficient lookup for the "non returning by name" test.

fix for build fix

Windows build fix.

Better return status labeling for shared funcs and Rose input sanitizing

If two functions share code, and function A parses into an already parsed function B,
we can be sure that B's return status is the same as function A's if B is contained
in A.  As of this commit, we assign B's return status to A if A parses into B's entry point.
This commit also sanitizes the pushf instruction so that it can be passed into Rose.

Make -cpumem work with getrusage() data on a per-test basis, with output added to the database driver.

Fix for bug 1141: bad register from fld ST0, foo with a REX prefix.

Merge branch 'master' of git.dyninst.org:/pub/dyninst

PowerPC slicing updates

Fix two bugs in Dyninst's exec handling code.

Both of these bugs were reported by the Open SpeedShop folks when
using Dyninst from the openssd daemon. They existed in both Dyninst 6.1
and GIT HEAD.

The first bug occurs when a multithread capable process exec's an executable
that is not multithread capable. We were incorrectly assuming that the exec'd
process was still multithread capable.

The second bug was observed when a multithread capable process exec's an
executable that is also multithread capable. The bug was that the tramp guard
AST was being cached across exec's and results in asserts in code generation
because the tramp guard variable created during mulitthreaded initialization
doesn't match the variable maintained by the tramp guard AST. The fix is to
clear the cached the tramp guard AST on exec.

Merge branch 'master' of ssh://git.dyninst.org/pub/dyninst

Untested verbose accounting code didn't compile

Merge branch 'master' of ssh://git.dyninst.org/pub/dyninst

Added missing std:: namespace specifiers.

Merge branch 'master' of ssh://git.dyninst.org/pub/dyninst

Power jump table parsing

1) Extensions to parseAPI(IA_powerDetails) to
find jump tables in ppc32 code.
The addi-addis combination instructions can
be anywhere in the function before the indirect
jump - not necessarily in the same block as the
indirect jump instruction.
The jump table start address is stored in got
section. For shared libraries, this is filled by
the dynamic loader via a relocation entry. Hence,
we should find the relocation entry corresponding
to the table start address to find the table in
rodata section.
2) symtabAPI: Relocation entries are added to
the corresponding DT_REL sections (rel.dyn and
rel.plt) in addition to the target region of the
relocations (plt section). This enables us to
get a list of relocations in a particular ELF
section.

Merge branch 'master' of ssh://git.dyninst.org/pub/dyninst

Added support for "callpath sensitive" backward slicing.

Various backward slicing bug fixes.

Added 2 new EdgePredicates: Interproc and SingleContextOrInterproc.

Merge branch 'master' of ssh://git.dyninst.org/pub/dyninst

Conflicts:
parseAPI/doc/parseapi.pdf

parseapi doc and codeRange fix

Bug 1139 fix

Test1_33 was failing in rewriter mode because
test1_33_globalVariable1 was initialized in the
bss section. The rewriter cannot modify variables
in the bss section. This commit initializes the
global variable to a non-zero value so that it
is not initialized in the bss section. This commit
fixes bug 1139

Merge branch 'master' of ssh://git.dyninst.org/pub/dyninst

Workarounds for old buggy versions of PGF (for ParseAPI manual front page)

Merge branch 'master' into devel

dataflowAPI: allow stack analysis to be disabled for AssignmentConverter

PPC64 Linux PLT call stack fix

We must store the caller's TOC into 40(r1) when replacing function calls
because the original call (to a PLT stub) would have stored the TOC there,
and subsequent code may expect to restore it.

Also removes an unnecessary dynamic_cast from parsing code.

Fixes an off-by-one error in Power decoder.

Various documentation updates to the ParseAPI manual

Testsuite changes

Added rewriter mode to test1_28, test1_33, test1_34 and init_fini_callback
on power, x86 and x86_64 linux platforms.

Implements the ProcControlAPI::ThreadPool::find function.

Modify ParseThat to return non-zero on mutator failure (or crash).

Mark CodeObjects unparseable when no valid code regions exist

Updated ParseAPI manual

Prevent duplicate return edge creation in Function::blocks_int

Implement PPC/Linux trap handler.

Merge branch 'master' of git.dyninst.org:/pub/dyninst

Conflicts:
dataflowAPI/src/Absloc.C

Fix stack comparison bug.

Fix stack comparison bug.

Conflicts:

dataflowAPI/h/slicing.h
dataflowAPI/src/slicing.C

Rearranged code for better ordering of if statements.

jumpSize() fix: take the absolute value of a signed value, not an unsigned.  This was breaking backwards branching on POWER.

Remove assert.

Treat blrl as a return, rather than a call, since in practice it is used as a linking return.

Ignore regions with zero memory size cross-platform.