Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / linux-ia64.C
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 /* -*- Mode: C; indent-tabs-mode: true; tab-width: 4 -*- */
33
34 #include <stdio.h>
35
36 // debugging... is there a Paradyn Standard for this?
37 #define TRACE(expr)     fprintf( stderr, "At line %d of %s in %s: %s.\n", __LINE__, __PRETTY_FUNCTION__,  __FILE__, __STRING(expr) );
38
39 #include "linux.h"
40 #include "inst-ia64.h"
41 #include "process.h"
42 #include "dyn_lwp.h"
43 #include "debuggerinterface.h"
44 #include "function.h"
45 #include "signalgenerator.h"
46 #include "mapped_object.h"
47
48 // For relocationEntry
49 #include "symtab.h"
50
51 /* For emitInferiorRPC*(). */
52 #include "rpcMgr.h"
53
54 #include "ast.h"
55 #include "registerSpace.h"
56
57 #include <asm/ptrace_offsets.h>
58 #include <dlfcn.h>
59
60 bool dyn_lwp::changePC( Address loc, dyn_saved_regs * regs ) {
61   if( regs != NULL ) { restoreRegisters( *regs ); }
62
63   /* We can't change the PC to a slot number other than 0. */  
64   assert( loc % 16 == 0 );
65
66   // /* DEBUG */ fprintf( stderr, "%s[%d]: (lwp %d) changing PC to 0x%lx\n", __FILE__, __LINE__, get_lwp_id(), loc );
67   return (getDBI()->ptrace( PTRACE_POKEUSER, get_lwp_id(), PT_CR_IIP, loc, -1, & errno ) != -1);
68 } /* end changePC() */
69
70 /* This should really be printRegisters().  I also have to admit
71    to some puzzlement as to the type of the parameter... */
72 void printRegs( void * /* save */ ) {
73   assert( 0 );
74 } /* end printRegs() */
75
76 /* dyn_lwp::getRegisters()
77  * 
78  * Entire user state can be described by struct pt_regs
79  * and struct switch_stack.  It's tempting to try and use
80  * pt_regs only, but only syscalls are that well behaved.
81  * We must support running arbitrary code.
82  */
83 bool dyn_lwp::getRegisters_( struct dyn_saved_regs *regs, bool/* includeFP*/ )
84 {
85    assert( status_ != running );
86
87    errno = 0;
88    regs->pc = getDBI()->ptrace( PTRACE_PEEKUSER, get_lwp_id(), PT_CR_IIP, 0, -1, & errno );
89    if (errno != 0)
90       return false;
91
92    /* If the PC may have rewound, handle it intelligently. */
93    needToHandleSyscall( this, & regs->pcMayHaveRewound );
94
95    /* We use the basetramp preservation code in our inferior RPCs, so we
96       don't have to preserve anything.  The only exception is the predicate
97       registers, because we may need them to handle system calls correctly.
98       (We predicate break instructions based on if the kernel attempted to
99       restart the system call.) */
100    regs->pr = getDBI()->ptrace( PTRACE_PEEKUSER, get_lwp_id(), PT_PR, 0, -1, & errno );
101    if (errno != 0)
102       return false;
103
104    return true;
105 } /* end getRegisters_() */
106
107 bool dyn_lwp::restoreRegisters_( const struct dyn_saved_regs &regs, bool/* includeFP*/ )
108 {
109    /* Restore the PC. */
110    if( ! regs.pcMayHaveRewound ) {
111       changePC( regs.pc, NULL );
112    }
113    else {
114       /* The flag could have only been set if the ipsr.ri at
115          construction-(and therefore run-)time ispr.ri was 0.  If it's 0
116          after the syscall trailer completes, then the original regs->pc
117          is correct.  If it's 2, then the PC rewound and we adjust
118          adjust regs->pc appropriately.  No other cases are possible. */
119       errno = 0;
120       uint64_t ipsr = getDBI()->ptrace( PTRACE_PEEKUSER, get_lwp_id(), PT_CR_IPSR, 0, -1, & errno );
121       if (errno != 0)
122          return false;
123
124       // /* DEBUG */ fprintf( stderr, "%s[%d]: pcMayHaveRewound.\n", FILE__, __LINE__ );
125
126       uint64_t ipsr_ri = (ipsr & 0x0000060000000000) >> 41;
127       assert( ipsr_ri <= 2 );
128
129       switch( ipsr_ri ) {
130          case 0:
131             // /* DEBUG */ fprintf( stderr, "%s[%d]: PC did not rewind.\n", FILE__, __LINE__ );
132             changePC( regs.pc, NULL );
133             break;
134          case 1:
135             assert( 0 );
136             break;
137          case 2:
138             /* DEBUG */ fprintf( stderr, "%s[%d]: PC rewound.\n", FILE__, __LINE__ );
139             changePC( regs.pc - 0x10, NULL );
140             break;
141          default:
142             assert( 0 );
143             break;
144       } /* end ispr_ri switch */
145    } /* end if pcMayHaveRewound */
146
147    /* Restore the predicate registers. */
148    int status = getDBI()->ptrace( PTRACE_POKEUSER, get_lwp_id(), PT_PR, regs.pr );
149    if (status != 0)
150       return false;
151
152    return true;
153 } /* end restoreRegisters_() */
154
155 void dyn_lwp::dumpRegisters()
156 {
157    dyn_saved_regs regs;
158    if (!getRegisters(&regs)) {
159       fprintf(stderr, "%s[%d]:  registers unavailable\n", FILE__, __LINE__);
160       return;
161    }
162
163    fprintf(stderr, "pc:   %lx\n", regs.pc);
164    fprintf(stderr, "pr:   %lx\n", regs.pr);
165 }
166
167 bool process::handleTrapAtEntryPointOfMain(dyn_lwp * /*dontcare*/) {
168    InsnAddr iAddr = InsnAddr::generateFromAlignedDataAddress( main_brk_addr, this );
169    iAddr.writeMyBundleFrom( savedCodeBuffer );
170
171    main_brk_addr = 0;
172    return true;
173 } /* end handleTrapAtEntryPointOfMain() */
174
175 bool process::insertTrapAtEntryPointOfMain() {
176    int_function *f_main = 0;
177    pdvector<int_function *> funcs;
178
179    //first check a.out for function symbol   
180    bool res = findFuncsByPretty("main", funcs);
181    if (!res)
182    {
183       logLine( "a.out has no main function. checking for PLT entry\n" );
184       //we have not found a "main" check if we have a plt entry
185       res = findFuncsByPretty( "DYNINST_pltMain", funcs );
186
187       if (!res) {
188          logLine( "no PLT entry for main found\n" );
189          return false;
190       }       
191    }
192
193    if( funcs.size() > 1 ) {
194       cerr << __FILE__ << __LINE__ 
195          << ": found more than one main! using the first" << endl;
196    }
197    f_main = funcs[0];
198    assert(f_main);
199    Address addr = f_main->getAddress();
200
201    InsnAddr iAddr = InsnAddr::generateFromAlignedDataAddress( addr, this );
202    iAddr.saveMyBundleTo( savedCodeBuffer );
203    iAddr.replaceBundleWith( generateTrapBundle() );
204
205    main_brk_addr = addr;
206    return true;
207 } /* end insertTrapAtEntryPointOfMain() */
208
209
210 bool process::handleTrapAtLibcStartMain(dyn_lwp *)  { assert(0); return false; }
211 bool process::instrumentLibcStartMain() { assert(0); return false; }
212 bool process::decodeStartupSysCalls(EventRecord &) { assert(0); return false; }
213 void process::setTraceSysCalls(bool) { assert(0); }
214 void process::setTraceState(traceState_t) { assert(0); }
215 bool process::getSysCallParameters(dyn_saved_regs *, long *, int) { assert(0); return false; }
216 int process::getSysCallNumber(dyn_saved_regs *) { assert(0); return 0; }
217 long process::getSysCallReturnValue(dyn_saved_regs *) { assert(0); return 0; }
218 Address process::getSysCallProgramCounter(dyn_saved_regs *) { assert(0); return 0; }
219 bool process::isMmapSysCall(int) { assert(0); return false; }
220 Offset process::getMmapLength(int, dyn_saved_regs *) { assert(0); return 0;}
221 Address process::getLibcStartMainParam(dyn_lwp *) { assert(0); return 0;}
222
223
224 #define BIT_8_3         0x1F8
225
226 /* private refactoring function; account for the RNAT slots. */
227 Address calculateRSEOffsetFromBySlots( Address addr, int slots ) {
228    /* Whenever bits 8:3 of BSPSTORE are all ones, the RSE stores 64 RNAT bits.
229       We'll just do this in the stupidest possible way. */
230
231    if( slots == 0 ) { return addr; }
232    int adjust = slots < 0 ? -1 : 1;
233
234    for( int i = 0; i < abs( slots ); i++ ) {
235       addr += adjust * 8;
236       if( (addr & BIT_8_3) == BIT_8_3 ) {
237          addr += adjust * 8;
238       } /* end if we ran into a NaT collection */
239    } /* end iteration over addresses */
240
241    return addr;
242 } /* end calculateRSEOffsetFromBySlots() */
243
244 Address dyn_lwp::readRegister( Register reg ) {
245    /* I can't find anything in the docs saying that ptrace()d
246       programs will always have a flushrs executed in their
247       context before the debugger gains control, but GDB seems
248       to think that this is the case, and we can't do anything
249       else to read registers anyway. */
250
251    /* Acquire the BSP. */
252    errno = 0;
253    Address bsp = getDBI()->ptrace( PTRACE_PEEKUSER, get_lwp_id(), PT_AR_BSP, 0, -1, & errno );
254    assert( ! errno );
255
256    /* Acquire the CFM. */
257    reg_tmpl tmpl = { getDBI()->ptrace( PTRACE_PEEKUSER, get_lwp_id(), PT_CFM, 0, -1, & errno ) };
258    assert( ! errno );
259
260    /* Calculate the address of the register. */
261    Address addressOfReg = calculateRSEOffsetFromBySlots( bsp, (-1 * tmpl.CFM.sof) + (reg - 32) );
262
263    /* Acquire and return the value of the register. */
264    Address value = getDBI()->ptrace( PTRACE_PEEKTEXT, get_lwp_id(), addressOfReg, 0, -1, & errno );
265    assert( ! errno );
266    return value;
267 } /* end readRegister */
268
269 #include <libunwind.h>
270 #include <libunwind-ptrace.h>
271
272 /* Refactored from getActiveFrame() and getCallerFrame(). */
273 Frame createFrameFromUnwindCursor( unw_cursor_t * unwindCursor, dyn_lwp * dynLWP, pid_t pid ) 
274 {
275    Address ip = 0, sp = 0, fp = 0, tp = 0;
276    bool isUppermost = false, isSignalFrame = false, isTrampoline = false;
277    int status = 0;
278
279    /* Use the unwind cursor to fill in the frame. */
280    status = getDBI()->getFrameRegister( unwindCursor, UNW_IA64_IP, &ip );
281    assert( status == 0 );
282    status = getDBI()->getFrameRegister( unwindCursor, UNW_IA64_SP, &sp );
283    assert( status == 0 );
284    status = getDBI()->getFrameRegister( unwindCursor, UNW_IA64_TP, &tp );
285    assert( status == 0 );
286
287    /* Unfortunately, libunwind is a little _too_ helpful:
288       it'll encode the slotNo into the ip.  Take it back
289       out, since we don't rely on it, and it confuses the
290       rest of Dyninst. */
291    ip = ip - (ip % 16);
292
293    status = getDBI()->isSignalFrame( unwindCursor );
294    if ( status > 0 ) { isSignalFrame = true; }
295
296    /* Determine if this is a trampoline frame. */
297    codeRange * range = dynLWP->proc()->findOrigByAddr( ip );
298
299    /* We assume here, and below, that the two stackwalking errors before
300       bootstrapping are from loading the run-time library. */
301    if ( range == NULL && dynLWP->proc()->reachedBootstrapState( bootstrapped_bs ) ) {
302 #if 0
303       /* We don't maintain the auxv page in the code range tree, so manually
304          check if we're in it. */
305       dynLWP->proc()->readAuxvInfo();
306       if( !( dynLWP->proc()->getVsyscallStart() <= ip && ip < dynLWP->proc()->getVsyscallEnd() )) {
307          /* DEBUG */ fprintf( stderr, "%s[%d]: warning: no code range found for ip 0x%lx\n", __FILE__, __LINE__, ip ); 
308       }
309 #endif
310    }
311    else {
312       if ( range->is_minitramp() != NULL || range->is_multitramp() != NULL ) {
313          isTrampoline = true;
314       } 
315       if ( range->is_function() != NULL && range->is_function()->symTabName() == "__libc_start_main" ) {
316          isUppermost = true;
317       }
318       if ( range->is_inferior_rpc() != NULL ) {
319          isUppermost = true;
320       }
321    }
322
323    /* Duplicate the current frame's cursor, since we'll be unwinding past it. */
324    unw_cursor_t currentFrameCursor = * unwindCursor;
325    status = getDBI()->stepFrameUp( unwindCursor );
326
327
328    if ( status < 0 ) {
329       if( range->is_inferior_rpc() != NULL ) {
330          // /* DEBUG */ fprintf( stderr, "%s[%d]: ignoring stackwalk failure in inferior RPC at 0x%lx.\n", __FILE__, __LINE__, ip );
331       }
332       else if( isUppermost ) {
333          /* DEBUG */ fprintf( stderr, "%s[%d]: ignoring stackwalk failure because frame at 0x%lx is a priori uppermost.\n", __FILE__, __LINE__, ip );
334       }
335       else if( ! dynLWP->proc()->reachedBootstrapState( bootstrapped_bs ) ) {
336          // /* DEBUG */ fprintf( stderr, "%s[%d]: ignoring stackwalk failure at 0x%lx because bootstrap is incomplete.\n", __FILE__, __LINE__, ip );
337       }
338       else {
339          /* Should we supress this warning? */
340          /*      fprintf( stderr, "%s[%d]: warning: failed to walk stack from address 0x%lx.\n", __FILE__, __LINE__, ip );*/
341       }
342    }
343
344    if ( status <= 0 ) {
345       isUppermost = true;
346    }
347
348    /* Since the rest of dyninst ignores isUppermost for some reason,
349       fake it by setting the frame pointer to 0. */
350    if ( ! isUppermost ) {
351       /* Set the frame pointer. */
352       status = getDBI()->getFrameRegister( unwindCursor, UNW_IA64_SP, & fp );
353       assert( status == 0 );
354    }
355
356    /* FIXME: multithread implementation. */
357    dyn_thread * dynThread = NULL;
358
359    Frame currentFrame( ip, fp, sp, pid, dynLWP->proc(), dynThread, dynLWP, isUppermost );
360    currentFrame.setUnwindCursor( currentFrameCursor );
361    currentFrame.setRange( range );
362
363    if( isTrampoline ) {
364       currentFrame.frameType_ = FRAME_instrumentation;
365    }
366    else if( isSignalFrame ) {
367       currentFrame.frameType_ = FRAME_signalhandler;
368    }
369    else {
370       currentFrame.frameType_ = FRAME_normal;
371    }
372
373    return currentFrame;
374 } /* end createFrameFromUnwindCursor() */
375
376 Frame dyn_lwp::getActiveFrame() 
377 {
378    int status = 0;
379    process * proc = proc_;
380
381    assert( status_ != running );
382
383    // /* DEBUG */ fprintf( stderr, "%s[%d]: getActiveFrame(): working on lwp %d\n", __FILE__, __LINE__, get_lwp_id() );
384
385    /* Initialize the unwinder. */
386    if( proc->unwindAddressSpace == NULL ) {
387       // /* DEBUG */ fprintf( stderr, "getActiveFrame(): Creating unwind address space for process pid %d\n", proc->getPid() );
388       proc->unwindAddressSpace = (unw_addr_space *) getDBI()->createUnwindAddressSpace( & _UPT_accessors, 0 );
389       assert( proc->unwindAddressSpace != NULL );
390    }
391
392    /* Initialize the thread-specific accessors. */
393    unsigned lid = get_lwp_id();
394    if( ! proc->unwindProcessArgs.defines( lid ) ) {
395       proc->unwindProcessArgs[ lid ] = getDBI()->UPTcreate( lid );
396       assert( proc->unwindProcessArgs[ lid ] != NULL );
397    }
398
399    /* Allocate an unwindCursor for this stackwalk. */
400    unw_cursor_t * unwindCursor = (unw_cursor_t *)malloc( sizeof( unw_cursor_t ) );
401    assert( unwindCursor != NULL );
402
403    /* Initialize it to the active frame. */
404    status = getDBI()->initFrame( unwindCursor, proc->unwindAddressSpace, proc->unwindProcessArgs[ lid ] );
405    assert( status == 0 );
406
407    /* Generate a Frame from the unwinder. */
408    Frame currentFrame = createFrameFromUnwindCursor( unwindCursor, this, lid );
409
410    /* createFrameFromUnwindCursor() copies the unwind cursor into the Frame it returns */
411    free( unwindCursor );
412
413    /* Return the result. */
414    return currentFrame;
415 } /* end getActiveFrame() */
416
417 #define DLOPEN_MODE             (RTLD_NOW | RTLD_GLOBAL)
418 #define DLOPEN_CALL_LENGTH      4
419
420 /* Defined in process.C; not sure why it isn't in a header. */
421 extern unsigned enable_pd_attach_detach_debug;
422
423 /* DEBUG code */
424 void printBinary( unsigned long long word, int start = 0, int end = 63 ) {
425    for( int i = start; i <= end; i++ ) {
426       if( i % 4 == 0 ) { fprintf( stderr,"\t" ); }
427       if( ( word << i ) & 0x8000000000000000 ) {
428          fprintf( stderr, "1" ); } else {
429             fprintf( stderr, "0" );  
430          }
431    }
432 } /* end printBinary() */
433
434 /* FIXME: this almost certainly NOT the Right Place to keep this. */
435 Address savedPC;
436
437 bool AddressSpace::getDyninstRTLibName() {
438    if (dyninstRT_name.length() == 0) {
439       // Get env variable
440       if (getenv("DYNINSTAPI_RT_LIB") != NULL) {
441          dyninstRT_name = getenv("DYNINSTAPI_RT_LIB");
442       }
443       else {
444          std::string msg = std::string( "Environment variable " + std::string( "DYNINSTAPI_RT_LIB" )
445                + " has not been defined");
446          showErrorCallback(101, msg);
447          return false;
448       }
449    }
450    // Check to see if the library given exists.
451    if (access(dyninstRT_name.c_str(), R_OK)) {
452       std::string msg = std::string("Runtime library ") + dyninstRT_name
453          + std::string(" does not exist or cannot be accessed!");
454       showErrorCallback(101, msg);
455       return false;
456    }
457    return true;
458 }
459
460 bool process::loadDYNINSTlib() {
461    /* Look for a function we can hijack to forcibly load dyninstapi_rt. 
462       This is effectively an inferior RPC with the caveat that we're
463       overwriting code instead of allocating memory from the RT heap. 
464       (So 'hijack' doesn't mean quite what you might think.) */
465    Address codeBase = findFunctionToHijack(this);       
466
467    if( !codeBase ) { return false; }
468
469    /* glibc 2.3.4 and higher adds a fourth parameter to _dl_open().
470       While we could probably get away with treating the three and four
471       -argument functions the same, check the version anyway, since
472       we'll probably need to later. */
473    bool useFourArguments = true;
474    int_symbol libcVersionSymbol;
475    if( getSymbolInfo( "__libc_version", libcVersionSymbol ) ) {
476       char libcVersion[ sizeof( int ) * libcVersionSymbol.getSize() + 1 ];
477       libcVersion[ sizeof( int ) * libcVersionSymbol.getSize() ] = '\0';
478       if( ! readDataSpace( (void *) libcVersionSymbol.getAddr(), libcVersionSymbol.getSize(), libcVersion, true ) ) {
479          fprintf( stderr, "%s[%d]: warning, failed to read libc version, assuming 2.3.4+\n", __FILE__, __LINE__ );
480       }
481       else {
482          startup_printf( "%s[%d]: libcVersion: %s\n", __FILE__, __LINE__, libcVersion );
483
484          /* We could potentially add a sanity check here to make sure we're looking at 2.3.x. */
485          int microVersion = ((int)libcVersion[4]) - ((int)'0');
486          if( microVersion <= 3 ) {
487             useFourArguments = false;
488          }
489       } /* end if we read the version symbol */
490    } /* end if we found the version symbol */
491
492    if( useFourArguments ) { startup_printf( "%s[%d]: using four arguments.\n", __FILE__, __LINE__ ); }
493
494    /* Fetch the name of the run-time library. */
495    const char DyninstEnvVar[]="DYNINSTAPI_RT_LIB";
496
497    if( ! dyninstRT_name.length() ) { // we didn't get anything on the command line
498       if (getenv(DyninstEnvVar) != NULL) {
499          dyninstRT_name = getenv(DyninstEnvVar);
500       } else {
501          std::string msg = std::string( "Environment variable " + std::string( DyninstEnvVar )
502                + " has not been defined for process " ) + utos( getPid() );
503          showErrorCallback(101, msg);
504          return false;
505       } /* end if enviromental variable not found */
506    } /* end enviromental variable extraction */
507
508    /* Save the (main thread's) current PC.*/
509    savedPC = getRepresentativeLWP()->getActiveFrame().getPC();  
510
511    /* _dl_open() takes three arguments: a pointer to the library name,
512       the DLOPEN_MODE, and the return address of the current frame
513       (that is, the location of the SIGILL-generating bundle we'll use
514       to handleIfDueToDyninstLib()).  We construct the first here. */
515
516    /* Write the string to entry, and then move the PC to the next bundle. */
517    codeGen gen(BYTES_TO_SAVE);
518    gen.setAddrSpace(this);
519    gen.setAddr(codeBase);
520
521    gen.setRegisterSpace(registerSpace::savedRegSpace(this));
522
523    Address dyninstlib_addr = gen.used() + codeBase;
524    gen.copy(dyninstRT_name.c_str(), dyninstRT_name.length()+1);
525
526    Address dlopencall_addr = gen.used() + codeBase;
527
528    /* At this point, we use the generic iRPC headers and trailers
529       around the call to _dl_open.  (Note that pre-1.35 versions
530       of this file had a simpler mechanism well-suited to boot-
531       strapping a new port.  The current complexity is to handle
532       the attach() case, where we don't know if execution was stopped
533       at the entry the entry point to a function. */
534
535    bool ok = theRpcMgr->emitInferiorRPCheader(gen);
536    if( ! ok ) { return false; }
537
538    /* Generate the call to _dl_open with a large dummy constant as the
539       the third argument to make sure we generate the same size code the second
540       time around, with the correct "return address." (dyninstlib_brk_addr) */
541    // As a quick note, we want to "return" to the beginning of the restore
542    // segment, not dyninstlib_brk_addr (or we skip all the restores).
543    // Of course, we're not sure what this addr represents....
544
545    pdvector< AstNodePtr > dlOpenArguments;
546    AstNodePtr dlOpenCall;
547
548    dlOpenArguments.push_back(AstNode::operandNode(AstNode::Constant, (void *)dyninstlib_addr));
549    dlOpenArguments.push_back(AstNode::operandNode(AstNode::Constant, (void *)DLOPEN_MODE ));
550    dlOpenArguments.push_back(AstNode::operandNode(AstNode::Constant, (void *)0xFFFFFFFFFFFFFFFF ));
551    if( useFourArguments ) { 
552       /* I derived the -2 as follows: from dlfcn/dlopen.c in the glibc sources, line 59,
553          we find the call to _dl_open(), whose last argument is 'args->file == NULL ? LM_ID_BASE : NS'.
554          Since the filename we pass in is non-null, this means we (would) pass in NS, which
555          is defined to be __LM_ID_CALLER in the same file, line 48.  (Since glibc must be shared
556          for us to be calling _dl_open(), we fall into the second case of the #ifdef.)  __LM_ID_CALLER
557          is defined in include/dlfcn.h, where it has the value -2. */
558       dlOpenArguments.push_back(AstNode::operandNode( AstNode::Constant, (void *)(long unsigned int)-2 ));
559    }
560
561    dlOpenCall = AstNode::funcCallNode( "_dl_open", dlOpenArguments );
562
563    /* Remember where we originally generated the call. */
564    codeBufIndex_t index = gen.getIndex();
565
566    /* emitInferiorRPCheader() configures (the global) registerSpace for us. */
567    dlOpenCall->generateCode( gen, true );
568
569    // Okay, we're done with the generation, and we know where we'll be.
570    // Go back and regenerate it
571    Address dlopenRet = codeBase + gen.used();
572    gen.setIndex(index);
573
574    /* Clean up the reference counts before regenerating. */
575
576    dlOpenArguments[ 2 ] = AstNode::operandNode( AstNode::Constant, (void *)dlopenRet );
577    dlOpenCall = AstNode::funcCallNode( "_dl_open", dlOpenArguments );
578
579    /* Regenerate the call at the same original location with the correct constants. */
580    dlOpenCall->generateCode( gen, true );
581
582    // Okay, that was fun. Now restore. And trap. And stuff.
583
584
585    unsigned breakOffset, resultOffset, justAfterResultOffset;
586    ok = theRpcMgr->emitInferiorRPCtrailer(gen, breakOffset, false, 
587          resultOffset, justAfterResultOffset );
588    if( ! ok ) { return false; }                                  
589
590    /* Let everyone else know that we're expecting a SIGILL. */
591    dyninstlib_brk_addr = codeBase + breakOffset;
592
593    assert(gen.used() < BYTES_TO_SAVE);
594
595    /* Save the function we're going to hijack. */
596    InsnAddr iAddr = InsnAddr::generateFromAlignedDataAddress( codeBase, this );
597    /* We need to save the whole buffer, because we don't know how big gen is
598       when we do the restore.  This could be made more efficient by storing
599       gen.used() somewhere. */
600    iAddr.saveBundlesTo( savedCodeBuffer, sizeof( savedCodeBuffer ) / 16 );
601
602    /* Write the call into the mutatee. */
603    InsnAddr jAddr = InsnAddr::generateFromAlignedDataAddress( codeBase, this );
604    jAddr.writeBundlesFrom( (unsigned char *)gen.start_ptr(), gen.used() / 16 );
605
606    /* Now that we know where the code will start, move the (main thread's) PC there. */
607    getRepresentativeLWP()->changePC( dlopencall_addr, NULL );
608
609    /* Let them know we're working on it. */
610    setBootstrapState( loadingRT_bs );
611
612    return true;
613 } /* end dlopenDYNINSTlib() */
614
615 bool process::loadDYNINSTlibCleanup(dyn_lwp * /*ignored*/) {
616    /* We function did we hijack? */
617    Address entry = findFunctionToHijack(this);  // We can avoid using InsnAddr because we know 
618    // that function entry points are aligned.
619    if( !entry ) { assert( 0 ); }
620
621    /* Restore the function we hijacked. */
622    InsnAddr iAddr = InsnAddr::generateFromAlignedDataAddress( entry, this );
623    iAddr.writeBundlesFrom( savedCodeBuffer, sizeof(savedCodeBuffer) / 16 );
624
625    /* Continue (the main thread's) execution at the correct point. */
626    getRepresentativeLWP()->changePC( savedPC, NULL );
627
628    return true;
629 } /* end loadDYNINSTlibCleanup() */
630
631 bool Frame::setPC( Address addr ) {
632    /* setPC() should only be called on a frame from a stackwalk.
633       If it isn't, we can duplicate the code below in getCallerFrame()
634       in order to create the necessary unwindCursor. */
635    assert( this->hasValidCursor );
636
637    /* Sanity-checking: ensure that the frame libunwind is setting is the same frame we are. */
638    Address ip;
639    getDBI()->getFrameRegister( & this->unwindCursor, UNW_IA64_IP, &ip );
640    assert( ip == pc_ );
641
642    /* Update the PC in the remote process. */
643    int status = getDBI()->setFrameRegister( & this->unwindCursor, UNW_IA64_IP, addr );
644    if( status != 0 ) {
645       fprintf( stderr, "Unable to set frame's PC: libunwind error %d\n", status );
646       return false;
647    }
648
649    /* Remember that we've done so. */
650    pc_ = addr;
651    range_ = NULL; // This has changed.
652    return true;
653 } /* end Frame::setPC() */
654
655 #include <miniTramp.h>
656 #include <baseTramp.h>  
657 #include <instPoint.h>
658 Frame Frame::getCallerFrame() {
659    int status = 0;      
660    assert( lwp_->status() != running );
661
662    /* Initialize the unwinder. */
663    if( getProc()->unwindAddressSpace == NULL ) {
664       // /* DEBUG */ fprintf( stderr, "Creating unwind address space for process pid %d\n", proc->getPid() );
665       getProc()->unwindAddressSpace = (unw_addr_space *)getDBI()->createUnwindAddressSpace( & _UPT_accessors, 0 );
666       assert( getProc()->unwindAddressSpace != NULL );
667    }
668
669    /* Initialize the thread-specific accessors. */
670    unsigned lid = lwp_->get_lwp_id();
671    if( ! getProc()->unwindProcessArgs.defines( lid ) ) {
672       getProc()->unwindProcessArgs[ lid ] = getDBI()->UPTcreate( lid );
673       assert( getProc()->unwindProcessArgs[ lid ] != NULL );
674    }
675
676    /* Generating the synthetic frame above the instrumentation is in cross-platform code. */
677
678    Frame currentFrame;
679    if( ! this->hasValidCursor ) {
680       /* DEBUG */ fprintf( stderr, "%s[%d]: no valid cursor in frame, regenerating.\n", __FILE__, __LINE__ );
681
682       /* Allocate an unwindCursor for this stackwalk. */
683       unw_cursor_t * unwindCursor = (unw_cursor_t *)malloc( sizeof( unw_cursor_t ) );
684       assert( unwindCursor != NULL );
685
686       /* Initialize it to the active frame. */
687       status = getDBI()->initFrame( unwindCursor, getProc()->unwindAddressSpace, getProc()->unwindProcessArgs[ lid ] );
688       assert( status == 0 );
689
690       /* Unwind to the current frame. */
691       currentFrame = createFrameFromUnwindCursor( unwindCursor, lwp_, lid );
692       while( ! currentFrame.isUppermost() ) {
693          if( getFP() == currentFrame.getFP() && getSP() == currentFrame.getSP() && getPC() == currentFrame.getPC() ) {
694             currentFrame = createFrameFromUnwindCursor( unwindCursor, lwp_, lid );
695             break;
696          } /* end if we've found this frame */
697          currentFrame = createFrameFromUnwindCursor( unwindCursor, lwp_, lid );
698       }
699
700       /* createFrameFromUnwindCursor() copies the unwind cursor into the Frame it returns. */
701       free( unwindCursor );     
702    } /* end if this frame was copied before being unwound. */
703    else {
704       /* Don't try to walk off the end of the stack. */
705       assert( ! this->uppermost_ );
706
707       /* Allocate an unwindCursor for this stackwalk. */
708       unw_cursor_t * unwindCursor = (unw_cursor_t *)malloc( sizeof( unw_cursor_t ) );
709       assert( unwindCursor != NULL );
710
711       /* Initialize it to this frame. */
712       * unwindCursor = this->unwindCursor;
713
714       /* Unwind the cursor to the caller's frame. */
715       int status = getDBI()->stepFrameUp( unwindCursor );
716
717       /* We unwound from this frame once before to get its FP. */
718       assert( status > 0 );
719
720       /* Create a Frame from the unwound cursor. */
721       currentFrame = createFrameFromUnwindCursor( unwindCursor, lwp_, lid );
722
723       /* createFrameFromUnwindCursor() copies the unwind cursor into the Frame it returns. */
724       free( unwindCursor );     
725    } /* end if this frame was _not_ copied before being unwound. */
726
727    /* Make sure we made progress. */    
728    if( getFP() == currentFrame.getFP() && getSP() == currentFrame.getSP() && getPC() == currentFrame.getPC() ) {        
729       /* This will forcibly terminate the stack walk. */
730       currentFrame.fp_ = (Address)NULL;
731       currentFrame.pc_ = (Address)NULL;
732       currentFrame.sp_ = (Address)NULL;
733       currentFrame.uppermost_ = false;
734
735       fprintf( stderr, "%s[%d]: detected duplicate stack frame, aborting stack with zeroed frame.\n", __FILE__, __LINE__ );
736    }
737
738    if( thread_ != NULL ) {
739       currentFrame.thread_ = thread_;
740    }
741
742    /* Return the result. */
743    return currentFrame;
744 } /* end getCallerFrame() */
745
746
747 /* Required by linux.C */
748 bool process::hasBeenBound( const relocationEntry &entry, int_function * & target_pdf, Address base_addr ) {
749    /* A PLT entry always looks up a function descriptor in the FD table in the .IA_64.pltoff section; if
750       the function hasn't been bound yet, that FD's function pointer will point to another PLT entry.
751       (Which will jump to the first, special PLT entry that calls the linker.) 
752
753       The relocation entry points directly to the descriptor, so only a single indirection is necessary. */
754
755    Address gotAddress = entry.rel_addr() + base_addr;
756    assert( gotAddress % 16 == 0 );
757    // /* DEBUG */ fprintf( stderr, "hasBeenBound(): checking entry at 0x%lx\n", gotAddress );
758
759    Address functionAddress;
760    if( ! this->readDataSpace( (const void *)gotAddress, 8, (void *) & functionAddress, true ) ) {
761       fprintf( stderr, "%s: failed to read from GOT (0x%lx)\n", __FUNCTION__, gotAddress );
762       return false;
763    }
764    // /* DEBUG */ fprintf( stderr, "hasBeenBound(): checking function address 0x%lx\n", functionAddress );
765
766    /* Do the look up.  We're skipping a potential optimization here (checking to see if
767       functionAddress is in the PLT first) for simplicitly. */
768    target_pdf = this->findFuncByAddr( functionAddress );
769    // /* DEBUG */ fprintf( stderr, "hasBeenBound(): found int_function at %p\n", target_pdf );
770    return ( target_pdf != NULL );
771 } /* end hasBeenBound() */
772
773 bool GetFrameRegisterCallback::operator()(unw_cursor_t *cp, 
774       unw_regnum_t reg, 
775       unw_word_t *valp)
776 {
777    lock->_Lock(FILE__, __LINE__);
778    cp_ = cp;
779    reg_ = reg;
780    valp_ = valp;
781    getMailbox()->executeOrRegisterCallback(this);
782    if (synchronous) {
783       dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
784       waitForCompletion();
785    }
786    lock->_Unlock(FILE__, __LINE__);
787    return true;
788 }
789
790 bool GetFrameRegisterCallback::execute_real()
791 {
792    ret = unw_get_reg(cp_, reg_, valp_);
793    return true;
794 }
795
796 int DebuggerInterface::getFrameRegister(unw_cursor_t *cp, unw_regnum_t reg, unw_word_t *valp)
797 {
798    getBusy();
799    int ret;
800    GetFrameRegisterCallback *cbp = new GetFrameRegisterCallback(&dbilock);
801    GetFrameRegisterCallback &cb = *cbp;
802
803    cb.enableDelete(false);
804    cb(cp, reg, valp);
805    ret = cb.getReturnValue();
806    cb.enableDelete();
807
808    releaseBusy();
809    return ret;
810 }
811
812 int DebuggerInterface::setFrameRegister(unw_cursor_t *cp, unw_regnum_t reg, unw_word_t val)
813 {
814    getBusy();
815    int ret;
816    SetFrameRegisterCallback *cbp = new SetFrameRegisterCallback(&dbilock);
817    SetFrameRegisterCallback &cb = *cbp;
818
819    cb.enableDelete(false);
820    cb(cp, reg, val);
821    ret = cb.getReturnValue();
822    cb.enableDelete();
823
824    releaseBusy();
825    return ret;
826 }
827 bool SetFrameRegisterCallback::operator()(unw_cursor_t *cp, 
828       unw_regnum_t reg, 
829       unw_word_t val)
830 {
831    lock->_Lock(FILE__, __LINE__);
832    cp_ = cp;
833    reg_ = reg;
834    val_ = val;
835    getMailbox()->executeOrRegisterCallback(this);
836    if (synchronous) {
837       dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
838       waitForCompletion();
839    }
840    lock->_Unlock(FILE__, __LINE__);
841    return true;
842 }
843
844 bool SetFrameRegisterCallback::execute_real()
845 {
846    ret = unw_set_reg(cp_, reg_, val_);
847    return true;
848 }
849
850 void * DebuggerInterface::createUnwindAddressSpace(unw_accessors_t *ap, int byteorder)
851 {
852    getBusy();
853    void * ret;
854    CreateUnwindAddressSpaceCallback *cbp = new CreateUnwindAddressSpaceCallback(&dbilock);
855    CreateUnwindAddressSpaceCallback &cb = *cbp;
856
857    cb.enableDelete(false);
858    cb(ap, byteorder);
859    ret = cb.getReturnValue();
860    cb.enableDelete();
861
862    releaseBusy();
863    return ret;
864 }
865
866 bool CreateUnwindAddressSpaceCallback::operator()(unw_accessors_t *ap, 
867       int byteorder) 
868 {
869    lock->_Lock(FILE__, __LINE__);
870    ap_ = ap;
871    byteorder_ = byteorder;
872    getMailbox()->executeOrRegisterCallback(this);
873    if (synchronous) {
874       dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
875       waitForCompletion();
876    }
877    lock->_Unlock(FILE__, __LINE__);
878   return true;
879 }
880
881 bool CreateUnwindAddressSpaceCallback::execute_real()
882 {
883   unw_addr_space *s = unw_create_addr_space(ap_, byteorder_);
884   ret = (void *) s;
885   return true;
886 }
887
888 int DebuggerInterface::destroyUnwindAddressSpace(unw_addr_space *as)
889 {
890   getBusy();
891   int ret;
892   DestroyUnwindAddressSpaceCallback *cbp = new DestroyUnwindAddressSpaceCallback(&dbilock);
893   DestroyUnwindAddressSpaceCallback &cb = *cbp;
894
895   cb.enableDelete(false);
896   cb(as);
897   ret = cb.getReturnValue();
898   cb.enableDelete();
899
900   releaseBusy();
901   return ret;
902 }
903
904 bool DestroyUnwindAddressSpaceCallback::operator()(unw_addr_space *as)
905 {
906   lock->_Lock(FILE__, __LINE__);
907   as_ = as;
908   getMailbox()->executeOrRegisterCallback(this);
909   if (synchronous) {
910     dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
911     waitForCompletion();
912   }
913   lock->_Unlock(FILE__, __LINE__);
914   return true;
915 }
916
917 bool DestroyUnwindAddressSpaceCallback::execute_real()
918 {
919   unw_destroy_addr_space(as_);
920   return true;
921 }
922 void *DebuggerInterface::UPTcreate(pid_t pid)
923 {
924   getBusy();
925   void * ret;
926   UPTCreateCallback *cbp = new UPTCreateCallback(&dbilock);
927   UPTCreateCallback &cb = *cbp;
928
929   cb.enableDelete(false);
930   cb(pid);
931   ret = cb.getReturnValue();
932   cb.enableDelete();
933
934   releaseBusy();
935   return ret;
936 }
937
938 bool UPTCreateCallback::operator()(pid_t pid)
939 {
940   lock->_Lock(FILE__, __LINE__);
941   pid_ = pid;
942   getMailbox()->executeOrRegisterCallback(this);
943   if (synchronous) {
944     dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
945     waitForCompletion();
946   }
947   lock->_Unlock(FILE__, __LINE__);
948   return true;
949 }
950
951 bool UPTCreateCallback::execute_real()
952 {
953   ret = _UPT_create(pid_);
954   return true;
955 }
956
957 void DebuggerInterface::UPTdestroy(void *handle)
958 {
959   getBusy();
960   UPTDestroyCallback *cbp = new UPTDestroyCallback(&dbilock);
961   UPTDestroyCallback &cb = *cbp;
962
963   cb.enableDelete(false);
964   cb(handle);
965   cb.enableDelete();
966
967   releaseBusy();
968 }
969
970 bool UPTDestroyCallback::operator()(void *handle)
971 {
972   lock->_Lock(FILE__, __LINE__);
973   handle_ = handle;
974   getMailbox()->executeOrRegisterCallback(this);
975   if (synchronous) {
976     dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
977     waitForCompletion();
978   }
979   lock->_Unlock(FILE__, __LINE__);
980   return true;
981 }
982
983 bool UPTDestroyCallback::execute_real()
984 {
985   _UPT_destroy(handle_);
986   return true;
987 }
988
989 int DebuggerInterface::initFrame(unw_cursor_t *cp, unw_addr_space_t as, void *arg)
990 {
991   getBusy();
992   int ret;
993   InitFrameCallback *cbp = new InitFrameCallback(&dbilock);
994   InitFrameCallback &cb = *cbp;
995
996   cb.enableDelete(false);
997   cb(cp, as, arg);
998   ret = cb.getReturnValue();
999   cb.enableDelete();
1000
1001   releaseBusy();
1002   return ret;
1003 }
1004
1005 bool InitFrameCallback::operator()(unw_cursor_t *cp, unw_addr_space_t as, void *arg)
1006 {
1007   lock->_Lock(FILE__, __LINE__);
1008   cp_ = cp;
1009   as_ = as;
1010   arg_ = arg;
1011   getMailbox()->executeOrRegisterCallback(this);
1012   if (synchronous) {
1013     dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
1014     waitForCompletion();
1015   }
1016   lock->_Unlock(FILE__, __LINE__);
1017   return true;
1018 }
1019
1020 bool InitFrameCallback::execute_real()
1021 {
1022   ret = unw_init_remote(cp_, as_, arg_);
1023   return true;
1024 }
1025
1026 int DebuggerInterface::stepFrameUp(unw_cursor_t *cp)
1027 {
1028   getBusy();
1029   int ret;
1030   StepFrameUpCallback *cbp = new StepFrameUpCallback(&dbilock);
1031   StepFrameUpCallback &cb = *cbp;
1032
1033   cb.enableDelete(false);
1034   cb(cp);
1035   ret = cb.getReturnValue();
1036   cb.enableDelete();
1037
1038   releaseBusy();
1039   return ret;
1040 }
1041
1042 bool StepFrameUpCallback::operator()(unw_cursor_t *cp)
1043 {
1044   lock->_Lock(FILE__, __LINE__);
1045   cp_ = cp;
1046   getMailbox()->executeOrRegisterCallback(this);
1047   if (synchronous) {
1048     dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
1049     waitForCompletion();
1050   }
1051   lock->_Unlock(FILE__, __LINE__);
1052   return true;
1053 }
1054
1055 bool StepFrameUpCallback::execute_real()
1056 {
1057   ret = unw_step(cp_);
1058   return true;
1059 }
1060
1061 bool DebuggerInterface::isSignalFrame(unw_cursor_t *cp)
1062 {
1063   getBusy();
1064   bool ret;
1065   IsSignalFrameCallback *cbp = new IsSignalFrameCallback(&dbilock);
1066   IsSignalFrameCallback &cb = *cbp;
1067
1068   cb.enableDelete(false);
1069   cb(cp);
1070   ret = cb.getReturnValue();
1071   cb.enableDelete();
1072
1073   releaseBusy();
1074   return ret;
1075 }
1076
1077 bool IsSignalFrameCallback::operator()(unw_cursor_t *cp)
1078 {
1079   lock->_Lock(FILE__, __LINE__);
1080   cp_ = cp;
1081   getMailbox()->executeOrRegisterCallback(this);
1082   if (synchronous) {
1083     dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
1084     waitForCompletion();
1085   }
1086   lock->_Unlock(FILE__, __LINE__);
1087   return true;
1088 }
1089
1090 bool IsSignalFrameCallback::execute_real()
1091 {
1092   ret = unw_is_signal_frame(cp_);
1093   return true;
1094 }
1095
1096 int DebuggerInterface::waitpid(pid_t pid, int *status, int options)
1097 {
1098   getBusy();
1099   int ret;
1100   WaitpidCallback *cbp = new WaitpidCallback(&dbilock);
1101   WaitpidCallback &cb = *cbp;
1102
1103   cb.enableDelete(false);
1104   cb(pid, status, options);
1105   ret = cb.getReturnValue();
1106   cb.enableDelete();
1107
1108   releaseBusy();
1109   return ret;
1110 }
1111 bool WaitpidCallback::operator()(pid_t pid, int *status, int options)
1112 {
1113   lock->_Lock(FILE__, __LINE__);
1114   pid_ = pid;
1115   status_ = status;
1116   options_ = options;
1117   getMailbox()->executeOrRegisterCallback(this);
1118   if (synchronous) {
1119     dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
1120     waitForCompletion();
1121   }
1122   lock->_Unlock(FILE__, __LINE__);
1123   return true;
1124 }
1125
1126 bool WaitpidCallback::execute_real()
1127 {
1128   ret = waitpid(pid_, status_, options_);
1129   return true;
1130 }
1131
1132 Frame process::preStackWalkInit(Frame startFrame)
1133 {
1134    /* Do a special check for the vsyscall page.  Silently drop
1135       the page if it exists. The IA-64 doesn't use DWARF to unwind out of 
1136       the vsyscall page, so calcVsyscallFrame() is overkill.
1137    */
1138     if( getVsyscallStart() == 0x0 ) {
1139         if( ! readAuxvInfo() ) {
1140             /* We're probably on Linux 2.4; use default values. */
1141             setVsyscallRange( 0xffffffffffffe000, 0xfffffffffffff000 );
1142         }
1143     }
1144     Address next_pc = startFrame.getPC();
1145     if (next_pc >= getVsyscallStart() && next_pc < getVsyscallEnd()) {
1146        return startFrame.getCallerFrame();
1147     }
1148     return startFrame;
1149 }