dyninstAPI: Expand powerpc support in image::findMain

First, this function needs to respect the ELF entry address, rather than
assuming that entry is at the start of the .text section.  This was
already handled in x86, so we just need the same in powerpc.

Second, we need to add ppc64 support to the section which currently
handles ppc32.  This requires dereferencing .opd indirection, and ppc64
also uses a TOC-based load which the current dataflowAPI code can't
handle.  For this case, just use a simple InstructionAPI eval with the
known TOC r2 register.

dyninstAPI: Let image::findMain inspect PIE too

Position-independent executables (PIE) are generally indistinguishable
from any other shared object, but we still need to find main() in these
when they're stripped.  One clue is the presence of INTERP, which PIEs
will always have.  (Some DSOs also have INTERP, but this is rare.)

Fix AddressSpace initialization order

Fix another unused parameter

Better warning fix for unused parameters

Commit f284f869b0b4 turned unused parameters into unused "dummy"
variables, which gcc 4.8 still warns about.  Using the parameter in a
void expression is a more reliable workaround.

Fix to handleCondDirExits

Removed nonexistent API call in ParseAPI::Block documentation

Finish the plumbing to ensure that added libraries including the RTlib get DT_NEEDED = SONAME.

Warning fix

Build fix

fileName() returns SONAME if present now, for proper DT_NEEDED updates when rewriting

Re-transpose arguments, because CMake 2.6 is dumb

Proper fix for building RTlib under CMake 2.6

Two more CMake 2.6 fixes: proper order of arguments, and only use LINK_PRIVATE where it's supported.

Fixed a CMake 2.6 bug where it wouldn't recognize libdwarf_imp as a target (and thus wouldn't add a libelf_imp dependency) if we weren't building our own libdwarf. Also cleaned up indentation (as in, it exists now in these CMake files).

Increase BG/Q attach timeout to five minutes.

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

# Please enter a commit message to explain why this merge is necessary,
# especially if it merges an updated upstream into a topic branch.
#
# Lines starting with '#' will be ignored, and an empty message aborts
# the commit.

Change __FILE__ to FILE__ prints in stackwalker to shorten logs

Fix PC/BGQ crashes on attach timeout

Implement PC memory usage interface on BGQ

Fix issue with optimization options not being used in RT library build

WIP for testing: properly track springboard locations persistently and per-process, rather than only persistent tracking of traps, globally

Clean up proccontrol debugging prints.  We now print base filenames rather than full paths in printfs

Clean RT library cmake cache before configuring to work around cmake bug where re-running cmake forgets the CMAKE_INSTALL_PREFIX

Fix procset iterator: we can't necessarily initialize the container from NULL. Had better be able to default-construct it though.

symtabAPI: Trim AObject and Object constructors.

Neither of these classes should ever be copied, so declare the standard
copy constructors as private, without implementation; operator= as well.
Remove a few other unimplemented constructors too.

Note: The updates to Object-nt were made by inspection only and should
be checked.  Object-coff and Object-xcoff were already using obsolete
AObject constructors; if dead they should be considered for removal.

Initialize thrd in a new FrameNode ctor

Reported by Coverity as UNINIT_CTOR.

Initialize and free PSetFeatures::memset

Reported by Coverity as UNINIT_CTOR

stackwalk: convert some stderr chatter to sw_printf

symtabAPI: Fix Coverity UNINIT_CTOR errors

symlite: Fix Coverity UNINIT_CTOR errors

stackwalk: Fix Coverity UNINIT_CTOR errors

proccontrol: Fix Coverity UNINIT_CTOR errors

parseAPI: Fix Coverity UNINIT_CTOR errors

instructionAPI: Fix Coverity UNINIT_CTOR errors

elf: Fix Coverity UNINIT_CTOR errors

dataflowAPI: Fix Coverity UNINIT_CTOR errors

common: Fix Coverity UNINIT_CTOR errors

Use 'delete' for objects created with 'new'

These two instances were incorrectly using free().

Reported by clang-analyzer as Memory Error : Bad deallocator.

Fix accidental switch fallthrough

These were reported by Coverity as MISSING_BREAK, and it seems true -
they should not be falling through to the next case.  Add breaks.

Annotate intentional switch fallthrough

These were reported by Coverity as MISSING_BREAK, but they're
intentionally falling through to the next case.  Coverity will infer
this intent if there's a comment in the last line instead of a break.

Reimplement Linux P_copy with fstream

Coverity reported RESOURCE_LEAK for the fds on error paths, and I see it
also doesn't check write() return value.  It's much easier to just let
fstream do the buffer management and IO.

Note: P_copy doesn't appear to actually be used anywhere, and the former
destination mode 0 was also suspicious.  Maybe it should be removed.

Reimplement getLinuxMaps in real C++

Coverity reported a few OVERFLOW weaknesses in the previous buffer-happy
code.  The whole function is much simpler using fstream to read maps.

emitElf: Fix possible sign-extension errors

When you have an expression type "<uint64_t> = <uint16_t> * <uint16_t>",
it sadly takes a detour into signed values.  The operands will be
promoted to int, then multiplied, then sign-extended to finally fill
uint64_t.  If the multiplication result is greater than 0x7fffffff,
overflowing int, then the top 32 bits of the uint64_t will all be 1s.
(That's if the compiler doesn't blow up the int overflow as undefined.)

The easiest solution is to forcefully promote the operands to the target
size and sign before multiplying.

Reported by Coverity as SIGN_EXTENSION.

stackwalk: Don't leak CallChecker instances

Both AnalysisStepperImpl and WandererHelper create CallCheckers in their
constructors, so they should delete in their deconstructors.

Reported by Coverity as CTOR_DTOR_LEAK.

proccontrol: Flatten up_notify as a member of int_notify

In the int_notify ctor, up_notify is newed, but this member is never
deleted.  Since this object never changes, it doesn't need to be a
pointer at all, so make it a direct member.

However, int_notify is a singleton that's never deleted, so the overall
leakiness isn't really changed here.

Reported by Coverity as CTOR_DTOR_LEAK.

symlite: Use pread rather than lseek save/restore

In SymLite::getInterpreterName, it was doing a SEEK_CUR, SEEK_SET,
read(), then SEEK_SET back to the original offset.  This can all be
replaced by using pread() to read from any offset without affecting the
actual file offset.

The former lseeks triggered Coverity CHECKED_RETURN & NEGATIVE_RETURNS.

common: Fix a sizeof error in calloc/realloc

An allocation resulting in (anno_list_t*) should not use the pointer
size, but rather sizeof(anno_list_t).  It just happened to be harmless
here because anno_list_t is itself typedef void*, so the same size.

Reported by Coverity as SIZEOF_MISMATCH.

patchAPI: Remove 'during' before destroying it

In PatchParseCallback::remove_edge_cb, if it has pe->points_.during,
then this is both destroyed and removed from PatchFunctions.  However,
PatchCallback::destroy will delete the point if not batching, and
PatchFunction::remove dereferences it, so destroy must come after.

Reported by Coverity as USE_AFTER_FREE.

proccontrol: Avoid dereferencing a deleted 'this'

In linux_process::preTerminate, a debug message asking, "Is this irony?"
has its own irony by calling getPid() when 'this' was just deleted.

Reported by Coverity as USE_AFTER_FREE.

symlite: Don't use a delete pointer

In SymElfFactory::closeSymbolReader, if 'ser' isn't in open_symelfs,
then it is deleted, so the function should return without using 'ser'
any more.

Reported by Coverity as USE_AFTER_FREE.

proccontrol: Fix a copy-paste typo in ppc_process::readInsnForSS

After iterating over all of map mm_for_ss, this function will create a
new mem_response for the request.  If that reports isReady() right away,
then the memcpy incorrectly copies from the previous map iterator, which
is now exhausted (==end()).  This appears to be a copy-paste typo of the
memcpy from within the for loop, and this memcpy should use new_resp.

Reported by Coverity as INVALIDATE_ITERATOR.

elf: Fix iteration in the destructor

In Elf_X::~Elf_X, the loop over elf_x_by_fd returns after it finds an
erases its element.  The loop over elf_x_by_ptr should do the same.
It's actually an error to continue the for loop with ++iter, because
map::erase() invalidates its iterator.

Reported by Coverity as INVALIDATE_ITERATOR.

Assert that dwarf_loclist_from_expr_a returns cnt==1

Coverity reports ARRAY_VS_SINGLETON in DwarfWalker::decodeExpression,
because the address of a singleton, &descs, is passed with cnt to
decodeLocationListForStaticOffsetOrAddress, which treats it as an array.
Without knowledge of cnt, the analyzer thinks this could be source of
memory corruption.

In fact, dwarf_loclist_from_expr_a always sets listlen (cnt) to 1 on
success.  If we assert this, then the analyzer can tell that the
singleton "array" bound is fine.

dataflowAPI: Correct an assertion test

Based on surrounding context, it seems clear that this assert meant to
test equality, not the result of assignment.

Reported by Coverity as ASSERT_SIDE_EFFECT.

We were double-adding field sizes to structs when they came from DWARF. This fixes that; we still need to add field sizes in cases where users create their own data types.

Indirect tail calls shouldn't count as unresolved control flow for instrumentation purposes.

Assorted bugfixes: don't die on DW_OP_piece, remove unimplemented stream operators from headers, bug fix for indirect tail calls, treat indirect symbols as functions in our aggregates, and handle DW_FORM_sec_offset.

Fixes for three bugs: tie CMake version dependency to use of the relevant features, check types for compatibility not pointer equality, and don't apply tail call heuristics to call instructions.

Merge branch 'master' into pc_mem_stats

Fix installation issues from RT library cmake split

Do include <linux/ptrace.h> for glibc prior to 2.7

Refactor RT library into separate CMake project so we can change compilers

Default to libiberty demangler

Enable built-in gcc demangler rather than libiberty's

Just include <sys/ptrace.h>

Ref: https://bugzilla.redhat.com/show_bug.cgi?id=991889

Merge branch 'clang-warnings'

PostponedSyscall fixes

Build downloaded packages in build dir rather than source dir.  Prevents conflicts when sharing source tree between platforms.

Fix an error message Address formatting [-Wstring-plus-int]

Remove extra parentheses for plain conditions [-Wparentheses-equality]

Add extra parentheses for assignment-as-condition  [-Wparentheses]

Convince Clang that it's possible for an EdgeTypeEnum to be -1

[-Wtautological-constant-out-of-range-compare]

Fix NULLs returned to bools [-Wnull-conversion]

Expand SW calltree interface to allow expanding and modifying CallTree.  Needed for STAT.

PPC64 build fix for SymtabAPI

New PC PlatFeature interface for querying process memory usage.  Implemented on BGQ and Linux

Hide sometimes-unused functions better [-Wunused-function]

- Mark ParserDetails.h is_code() static inline, so compilation units
  which don't call it will just ignore it.

- Only define aix_region_hack() if define(os_aix).

Fix issue where we were using the wrong BGQ compiler for the RT library

Fix BGQ build error in RT library

Remove unused data members [-Wunused-private-field]

Use (void) to squash unused variables [-Wself-assign]

Clang complains about the previous code:

  warning: explicitly assigning a variable [...] to itself

findProcLWPs: initialize lwp_ppid [-Wsometimes-uninitialized]

Separate unclear "=-" into "= -"

These gave clang cause for concern, like:

  warning: use of unary operator that may be intended as
  compound assignment (-=)

I believe they really are just meant to assign negative values.

Fix string termination [-Wnon-literal-null-conversion]

These two lines were setting their pointers to '\0', effectively NULL,
rather than writing the value pointed to.

Reconcile class/struct declarations [-Wmismatched-tags]

Let Dyninst itself be compiled with Clang on Linux

With clang-3.3-0.10.rc3.fc19.x86_64 and libstdc++-4.8.2-1.fc19.x86_64,
the fixes required were as follows:

- cmake files looking for CMAKE_COMPILER_IS_GNUCXX need to also
  recognize CMAKE_CXX_COMPILER_ID "Clang".

- The ListHash macro had a pointer->int cast that halted Clang.

- Several templates in rose/*InstructionSemantics.h couldn't be resolved
  implicitly; they're now either made explicit or converted to typename.

- ppc32::cr0.val() is apparently not const enough for Clang as a
  template parameter; changed to ppc32::icr0.

common: Use __GLIBCXX__ for libstdc++ checks

A Dyninst client might choose to compile with Clang and libstdc++.
Clang does set __GNUC__ macros, but only as if it were GCC 4.2.1, which
means checks looking for libstdc++ features were misled.  Those checks
are better served by __GLIBCXX__, which is a unique date stamp for each
GCC release.

dyninstAPI: Remove syscall instrumentation on detach

During PCProcess::bootstrapProcess(), many syscalls are instrumented,
which may involve DyninstAPI_RT breakpoints.  If the mutator later
detaches, then there's no one to catch the instrumentation signal, so
the detached mutatee will crash.

With this patch, PCProcess will remove its syscall instrumentation
points when the mutator detaches.  It's still up to mutators to remove
their own instrumentation when desired.

Reported-by: Zifei Tong <soariez@gmail.com>
Signed-off-by: Josh Stone <jistone@redhat.com>

Wait for PTRACE_SYSCALL after mid-syscall PTRACE_EVENTs

It is found that PTRACE_EVENT_FORK, _CLONE, and _EXEC all trigger in the
middle of the syscall in question.  It is not safe to modify the mutatee
at this point, because the syscall return value may not be written into
registers yet.

For instance, test4_2 does some post-fork instrumentation on the parent,
which triggers an iRPC on x86_64.  To run the iRPC, the process state is
saved, state is overwritten to setup the iRPC, process continues, then
state is restored.  When the syscall return value isn't written until
that continue, then it will be lost and we've saved+restored the wrong
value.  This results in test4_2 reporting "fork result: 56" (SYS_clone),
or it may even get -1 and errno=ENOSYS if syscall auditing is enabled.

The exact symptom is kernel-dependent.  The utrace-patched ptrace on
RHEL6 actually did wait to fire the event until after the fork result
was written, so it had no problem.  RHEL5 and Fedora 19 do show the bad
fork result though.

The solution is to create a new "postponed syscall" state, and resume
the process with PTRACE_SYSCALL to finish up the syscall related to the
PTRACE_EVENT first.  Only then is the event actually processed and
callbacks are delivered as needed.

* When rewriting a binary and introducing one-page offsets w.r.t. its old virtual addresses, ensure that loadable segments are aligned to a single page, not multiple pages.
* Fixes to get parseThat to build properly against a CMake-installed Dyninst.

Experimental: support parsing of indirect tail calls when they appear as a function's only instructions and lack stack teardown.

Null check, don't blithely assume we have type info.

Fix a bad merge that broke Springboard

In commit 8a035430164e, I removed the 'size' variable from
SpringboardBuilder::generateSpringboard(), as it was not used.

In commit 31b4cd373cd6, Bill initialized 'size' with a proper
value and used it in the call to registerBranch().

When git merged these, it reconciled the changed initialization on its
own, but also kept out a 'size = 1' that I had removed and Bill hadn't
touched.  That assignment is needed now that the variable is used.

common: Canonicalize '//' out of #include paths

Such paths confuse rpm debugedit; see rhbz304121.

Merge branch 'jistone/coverity'

Fix infinite loops in x86/x86_64 tc_lock_lock

With -fvisibility=hidden, gcc gets too smart and inlines atomic_set into
tc_lock_lock.  The optimizer can't tell that the asm in atomic_set is
changing anything, because its input is a fixed pointer, not the
volatile value it points too.  So the x86_64 lock loop looks like this:

  34:   48 c7 c0 01 00 00 00    mov    $0x1,%rax
  3b:   48 89 d9                mov    %rbx,%rcx
  3e:   f0 48 87 01             lock xchg %rax,(%rcx)
  42:   48 89 c2                mov    %rax,%rdx
  45:   0f 1f 00                nopl   (%rax)
  48:   48 85 d2                test   %rdx,%rdx
  4b:   75 fb                   jne    48 <tc_lock_lock+0x28>

That is, on failure 4b jumps back to 48 forever.  It's also not really
correct to be using a 64-bit xchg, since the memory value is just int.
The 32-bit x86 version gets a similar loop with the xchg lifted out.

This patch greatly simplifies the asm, with its input "+m"(*val) ensuring
that gcc knows we're using the volatile value, and a broad "memory"
constraint so the lock can protect other data too.  That loop is now:

  11:   b9 01 00 00 00          mov    $0x1,%ecx
  16:   66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)
  1d:   00 00 00
  20:   89 ca                   mov    %ecx,%edx
  22:   87 13                   xchg   %edx,(%rbx)
  24:   85 d2                   test   %edx,%edx
  26:   75 f8                   jne    20 <tc_lock_lock+0x20>

Signed-off-by: Josh Stone <jistone@redhat.com>

Really enable -fvisibility=hidden for GCC builds

The visibility flags were being added after the component directories
were specified, which apparently means those subdirectories don't get
the same flags.  Also, the flags weren't quoted correctly when defined,
and -fvisibility-inlines-hidden is only valid for C++.

Now the flags are defined using cmake/visibility.cmake, mimicking
warnings.cmake, and included in the same place in CMakeLists.txt.

I've found no regressions from this change, and there's a substantial
reduction in the size of the libraries.

Signed-off-by: Josh Stone <jistone@redhat.com>

Fix DYNINST_index_lock state and ppc64 writeFunctionPtr

There are two fixes in this patch to resolve hangs that we've seen on
ppc64 tests, most notably in test_thread_5.

The first is that DYNINST_index_lock may be left in a locked state from
DYNINSTthreadIndexSLOW when DYNINST_thread_hash_size is 0.  This simply
needs an unlock in that error path.

The second resolves *why* DYNINST_thread_hash_size is 0, even after it
was correctly initialized to 40.  This turned out to be corruption when
the mutator writeFunctionPtr sets DYNINST_pthread_self.  Those symbols
in libdyninstAPI_RT.so happen to be arranged like so:

    0000000000031180 B DYNINST_pthread_self
    0000000000031188 B DYNINST_sysEntry
    0000000000031190 B DYNINST_thread_hash_size

So writeFunctionPtr was sending three longs: the function descriptor
correctly in DYNINST_pthread_self; the toc in DYNINST_sysEntry, a dead
variable; and the guilty 0x0 in DYNINST_thread_hash_size.  The only
thing a function pointer actually needs is the function descriptor.

For comparison, on EL5 and EL6 our build has the symbols like so:

    000000000002c400 B DYNINST_pthread_self
    000000000002c408 B DYNINSTlinkSave
    000000000002c410 B DYNINSTtocSave
    000000000002c418 B DYNINST_sysEntry
    000000000002c420 B DYNINST_thread_hash_tids
    000000000002c428 B DYNINST_thread_hash_size

So that still clobbered data, but DYNINSTlinkSave and DYNINSTtocSave are
both unused variables -- no harm done.

Signed-off-by: Josh Stone <jistone@redhat.com>

Don't stop mutatees for SIGINT

In PCEventHandler::shouldStopForSignal(), SIGINT is not a stopping
signal.  SIGINT's default action is to terminate the process, but it can
also be handled or ignored.  It never stops, to my knowledge.

It's hard for me to know the original author's intent, but the other
match on SIGSTOP does make sense.  SIGTSTP, SIGTTIN, and SIGTTOU are
also stopping signals, FWIW, but those may still be caught or ignored.