OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [doc/] [interface.texi] - Blame information for rev 284

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 284 jeremybenn
@c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
2
@c 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3
@c This is part of the GCC manual.
4
@c For copying conditions, see the file gcc.texi.
5
 
6
@node Interface
7
@chapter Interfacing to GCC Output
8
@cindex interfacing to GCC output
9
@cindex run-time conventions
10
@cindex function call conventions
11
@cindex conventions, run-time
12
 
13
GCC is normally configured to use the same function calling convention
14
normally in use on the target system.  This is done with the
15
machine-description macros described (@pxref{Target Macros}).
16
 
17
@cindex unions, returning
18
@cindex structures, returning
19
@cindex returning structures and unions
20
However, returning of structure and union values is done differently on
21
some target machines.  As a result, functions compiled with PCC
22
returning such types cannot be called from code compiled with GCC,
23
and vice versa.  This does not cause trouble often because few Unix
24
library routines return structures or unions.
25
 
26
GCC code returns structures and unions that are 1, 2, 4 or 8 bytes
27
long in the same registers used for @code{int} or @code{double} return
28
values.  (GCC typically allocates variables of such types in
29
registers also.)  Structures and unions of other sizes are returned by
30
storing them into an address passed by the caller (usually in a
31
register).  The target hook @code{TARGET_STRUCT_VALUE_RTX}
32
tells GCC where to pass this address.
33
 
34
By contrast, PCC on most target machines returns structures and unions
35
of any size by copying the data into an area of static storage, and then
36
returning the address of that storage as if it were a pointer value.
37
The caller must copy the data from that memory area to the place where
38
the value is wanted.  This is slower than the method used by GCC, and
39
fails to be reentrant.
40
 
41
On some target machines, such as RISC machines and the 80386, the
42
standard system convention is to pass to the subroutine the address of
43
where to return the value.  On these machines, GCC has been
44
configured to be compatible with the standard compiler, when this method
45
is used.  It may not be compatible for structures of 1, 2, 4 or 8 bytes.
46
 
47
@cindex argument passing
48
@cindex passing arguments
49
GCC uses the system's standard convention for passing arguments.  On
50
some machines, the first few arguments are passed in registers; in
51
others, all are passed on the stack.  It would be possible to use
52
registers for argument passing on any machine, and this would probably
53
result in a significant speedup.  But the result would be complete
54
incompatibility with code that follows the standard convention.  So this
55
change is practical only if you are switching to GCC as the sole C
56
compiler for the system.  We may implement register argument passing on
57
certain machines once we have a complete GNU system so that we can
58
compile the libraries with GCC@.
59
 
60
On some machines (particularly the SPARC), certain types of arguments
61
are passed ``by invisible reference''.  This means that the value is
62
stored in memory, and the address of the memory location is passed to
63
the subroutine.
64
 
65
@cindex @code{longjmp} and automatic variables
66
If you use @code{longjmp}, beware of automatic variables.  ISO C says that
67
automatic variables that are not declared @code{volatile} have undefined
68
values after a @code{longjmp}.  And this is all GCC promises to do,
69
because it is very difficult to restore register variables correctly, and
70
one of GCC's features is that it can put variables in registers without
71
your asking it to.

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.