1 /* -----------------------------------------------------------------------------
3 * (c) The GHC Team, 1998-1999
5 * Stuff for implementing proper tail jumps.
7 * ---------------------------------------------------------------------------*/
12 /* -----------------------------------------------------------------------------
13 Unmangled tail-jumping: use the mini interpretter.
14 -------------------------------------------------------------------------- */
16 #ifdef USE_MINIINTERPRETER
18 #define JMP_(cont) return((StgFunPtr)(cont))
24 extern void __DISCARD__(void);
26 /* -----------------------------------------------------------------------------
28 -------------------------------------------------------------------------- */
32 /* Note about discard: possibly there to fool GCC into clearing up
33 before we do the jump eg. if there are some arguments left on the C
34 stack that GCC hasn't popped yet. Also possibly to fool any
35 optimisations (a function call often acts as a barrier). Not sure
36 if any of this is necessary now -- SDM
38 Comment to above note: I don't think the __DISCARD__() in JMP_ is
39 necessary. Arguments should be popped from the C stack immediately
40 after returning from a function, as long as we pass -fno-defer-pop
41 to gcc. Moreover, a goto to a first-class label acts as a barrier
42 for optimisations in the same way a function call does.
46 /* The goto here seems to cause gcc -O2 to delete all the code after
47 it - including the FE_ marker and the epilogue code - exactly what
55 __target = (void *)(cont); \
59 #endif /* i386_HOST_ARCH */
61 /* -----------------------------------------------------------------------------
62 Tail calling on x86_64
63 -------------------------------------------------------------------------- */
68 NOTE about __DISCARD__():
70 On x86_64 this is necessary to work around bugs in the register
71 variable support in gcc. Without the __DISCARD__() call, gcc will
72 silently throw away assignements to global register variables that
73 happen before the jump.
84 without the dummy function call, gcc throws away the assignment to R1
85 (gcc 3.4.3) gcc bug #20359.
92 __target = (void *)(cont); \
96 #endif /* x86_64_HOST_ARCH */
98 /* -----------------------------------------------------------------------------
100 -------------------------------------------------------------------------- */
102 #ifdef sparc_HOST_ARCH
104 #define JMP_(cont) ((F_) (cont))()
105 /* Oh so happily, the above turns into a "call" instruction,
106 which, on a SPARC, is nothing but a "jmpl" with the
107 return address in %o7 [which we don't care about].
110 /* Don't need these for sparc mangling */
114 #endif /* sparc_HOST_ARCH */
116 /* -----------------------------------------------------------------------------
117 Tail calling on Alpha
118 -------------------------------------------------------------------------- */
120 #ifdef alpha_HOST_ARCH
123 register void *_procedure __asm__("$27");
127 do { _procedure = (void *)(cont); \
132 /* Don't need these for alpha mangling */
136 #endif /* alpha_HOST_ARCH */
138 /* -----------------------------------------------------------------------------
141 Description of HP's weird procedure linkage, many thanks to Andy Bennet
142 <andy_bennett@hp.com>:
144 I've been digging a little further into the problem of how HP-UX does
145 dynamic procedure calls. My solution in the last e-mail inserting an extra
146 'if' statement into the JMP_ I think is probably the best general solution I
147 can come up with. There are still a few problems with it however: It wont
148 work, if JMP_ ever has to call anything in a shared library, if this is
149 likely to be required it'll need something more elaborate. It also wont work
150 with PA-RISC 2.0 wide mode (64-bit) which uses a different format PLT.
152 I had some feedback from someone in HP's compiler lab and the problem
153 relates to the linker on HP-UX, not gcc as I first suspected. The reason the
154 'hsc' executable works is most likely due to a change in 'ld's behaviour for
155 performance reasons between your revision and mine.
157 The major issue relating to this is shared libraries and how they are
158 implented under HP-UX. The whole point of the Procedure Label Table (PLT) is
159 to allow a function pointer to hold the address of the function and a
160 pointer to the library's global data lookup table (DLT) used by position
161 independent code (PIC). This makes the PLT absolutely essential for shared
162 library calls. HP has two linker introduced assembly functions for dealing
163 with dynamic calls, $$dyncall and $$dyncall_external. The former does a
164 check to see if the address is a PLT pointer and dereferences if necessary
165 or just calls the address otherwise; the latter skips the check and just
166 does the indirect jump no matter what.
168 Since $$dyncall_external runs faster due to its not having the test, the
169 linker nowadays prefers to generate calls to that, rather than $$dyncall. It
170 makes this decision based on the presence of any shared library. If it even
171 smells an sl's existence at link time, it rigs the runtime system to
172 generate PLT references for everything on the assumption that the result
173 will be slightly more efficient. This is what is crashing GHC since the
174 calls it is generating have no understanding of the procedure label proper.
175 The only way to get real addresses is to link everything archive, including
176 system libraries, at which point it assumes you probably are going to be
177 using calls similar to GHC's (its rigged for HP's +ESfic compiler option)
178 but uses $$dyncall if necessary to cope, just in case you aren't.
180 -------------------------------------------------------------------------- */
182 #ifdef hppa1_1_hp_hpux_TARGET
185 do { void *_procedure = (void *)(cont); \
186 if (((int) _procedure) & 2) \
187 _procedure = (void *)(*((int *) (_procedure - 2))); \
191 #endif /* hppa1_1_hp_hpux_TARGET */
193 /* -----------------------------------------------------------------------------
194 Tail calling on PowerPC
195 -------------------------------------------------------------------------- */
197 #ifdef powerpc_HOST_ARCH
202 target = (void *)(cont); \
208 The __DISCARD__ is there because Apple's April 2002 Beta of GCC 3.1
209 sometimes generates incorrect code otherwise.
210 It tends to "forget" to update global register variables in the presence
211 of decrement/increment operators:
212 JMP_(*(--Sp)) is wrongly compiled as JMP_(Sp[-1]).
213 Calling __DISCARD__ in between works around this problem.
217 I would _love_ to use the following instead,
218 but some versions of Apple's GCC fail to generate code for it
219 if it is called for a casted data pointer - which is exactly what
220 we are going to do...
222 #define JMP_(cont) ((F_) (cont))()
225 #endif /* powerpc_HOST_ARCH */
227 #ifdef powerpc64_HOST_ARCH
228 #define JMP_(cont) ((F_) (cont))()
231 /* -----------------------------------------------------------------------------
233 -------------------------------------------------------------------------- */
235 #ifdef ia64_HOST_ARCH
237 /* The compiler can more intelligently decide how to do this. We therefore
238 * implement it as a call and optimise to a jump at mangle time. */
239 #define JMP_(cont) ((F_) (cont))(); __asm__ volatile ("--- TAILCALL ---");
241 /* Don't emit calls to __DISCARD__ as this causes hassles */
242 #define __DISCARD__()
246 /* -----------------------------------------------------------------------------
249 These are markers indicating the start and end of Real Code in a
250 function. All instructions between the actual start and end of the
251 function and these markers is shredded by the mangler.
252 -------------------------------------------------------------------------- */
254 /* The following __DISCARD__() has become necessary with gcc 2.96 on x86.
255 * It prevents gcc from moving stack manipulation code from the function
256 * body (aka the Real Code) into the function prologue, ie, from moving it
257 * over the --- BEGIN --- marker. It should be noted that (like some
258 * other black magic in GHC's code), there is no essential reason why gcc
259 * could not move some stack manipulation code across the __DISCARD__() -
260 * it just doesn't choose to do it at the moment.
265 #define FB_ __asm__ volatile ("--- BEGIN ---"); __DISCARD__ ();
269 #define FE_ __asm__ volatile ("--- END ---");
272 #endif /* !USE_MINIINTERPRETER */
274 #endif /* TAILCALLS_H */