1 | /* Operating system specific defines to be used when targeting GCC for some |
---|
2 | generic System V Release 4 system. |
---|
3 | Copyright (C) 1991, 1994, 1995 Free Software Foundation, Inc. |
---|
4 | Contributed by Ron Guilmette (rfg@segfault.us.com). |
---|
5 | |
---|
6 | This file is part of GNU CC. |
---|
7 | |
---|
8 | GNU CC is free software; you can redistribute it and/or modify |
---|
9 | it under the terms of the GNU General Public License as published by |
---|
10 | the Free Software Foundation; either version 2, or (at your option) |
---|
11 | any later version. |
---|
12 | |
---|
13 | GNU CC is distributed in the hope that it will be useful, |
---|
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
16 | GNU General Public License for more details. |
---|
17 | |
---|
18 | You should have received a copy of the GNU General Public License |
---|
19 | along with GNU CC; see the file COPYING. If not, write to |
---|
20 | the Free Software Foundation, 59 Temple Place - Suite 330, |
---|
21 | Boston, MA 02111-1307, USA. |
---|
22 | |
---|
23 | To use this file, make up a file with a name like: |
---|
24 | |
---|
25 | ?????svr4.h |
---|
26 | |
---|
27 | where ????? is replaced by the name of the basic hardware that you |
---|
28 | are targeting for. Then, in the file ?????svr4.h, put something |
---|
29 | like: |
---|
30 | |
---|
31 | #include "?????.h" |
---|
32 | #include "svr4.h" |
---|
33 | |
---|
34 | followed by any really system-specific defines (or overrides of |
---|
35 | defines) which you find that you need. For example, CPP_PREDEFINES |
---|
36 | is defined here with only the defined -Dunix and -DSVR4. You should |
---|
37 | probably override that in your target-specific ?????svr4.h file |
---|
38 | with a set of defines that includes these, but also contains an |
---|
39 | appropriate define for the type of hardware that you are targeting. |
---|
40 | */ |
---|
41 | |
---|
42 | /* Define a symbol indicating that we are using svr4.h. */ |
---|
43 | #define USING_SVR4_H |
---|
44 | |
---|
45 | /* For the sake of libgcc2.c, indicate target supports atexit. */ |
---|
46 | #define HAVE_ATEXIT |
---|
47 | |
---|
48 | /* Cpp, assembler, linker, library, and startfile spec's. */ |
---|
49 | |
---|
50 | /* This defines which switch letters take arguments. On svr4, most of |
---|
51 | the normal cases (defined in gcc.c) apply, and we also have -h* and |
---|
52 | -z* options (for the linker). Note however that there is no such |
---|
53 | thing as a -T option for svr4. */ |
---|
54 | |
---|
55 | #define SWITCH_TAKES_ARG(CHAR) \ |
---|
56 | ( (CHAR) == 'D' \ |
---|
57 | || (CHAR) == 'U' \ |
---|
58 | || (CHAR) == 'o' \ |
---|
59 | || (CHAR) == 'e' \ |
---|
60 | || (CHAR) == 'u' \ |
---|
61 | || (CHAR) == 'I' \ |
---|
62 | || (CHAR) == 'm' \ |
---|
63 | || (CHAR) == 'L' \ |
---|
64 | || (CHAR) == 'A' \ |
---|
65 | || (CHAR) == 'h' \ |
---|
66 | || (CHAR) == 'z') |
---|
67 | |
---|
68 | /* This defines which multi-letter switches take arguments. On svr4, |
---|
69 | there are no such switches except those implemented by GCC itself. */ |
---|
70 | |
---|
71 | #define WORD_SWITCH_TAKES_ARG(STR) \ |
---|
72 | (DEFAULT_WORD_SWITCH_TAKES_ARG (STR) \ |
---|
73 | && strcmp (STR, "Tdata") && strcmp (STR, "Ttext") \ |
---|
74 | && strcmp (STR, "Tbss")) |
---|
75 | |
---|
76 | /* You should redefine CPP_PREDEFINES in any file which includes this one. |
---|
77 | The definition should be appropriate for the type of target system |
---|
78 | involved, and it should include any -A (assertion) options which are |
---|
79 | appropriate for the given target system. */ |
---|
80 | #undef CPP_PREDEFINES |
---|
81 | |
---|
82 | /* Provide an ASM_SPEC appropriate for svr4. Here we try to support as |
---|
83 | many of the specialized svr4 assembler options as seems reasonable, |
---|
84 | given that there are certain options which we can't (or shouldn't) |
---|
85 | support directly due to the fact that they conflict with other options |
---|
86 | for other svr4 tools (e.g. ld) or with other options for GCC itself. |
---|
87 | For example, we don't support the -o (output file) or -R (remove |
---|
88 | input file) options because GCC already handles these things. We |
---|
89 | also don't support the -m (run m4) option for the assembler because |
---|
90 | that conflicts with the -m (produce load map) option of the svr4 |
---|
91 | linker. We do however allow passing arbitrary options to the svr4 |
---|
92 | assembler via the -Wa, option. |
---|
93 | |
---|
94 | Note that gcc doesn't allow a space to follow -Y in a -Ym,* or -Yd,* |
---|
95 | option. |
---|
96 | */ |
---|
97 | |
---|
98 | #undef ASM_SPEC |
---|
99 | #define ASM_SPEC \ |
---|
100 | "%{V} %{v:%{!V:-V}} %{Qy:} %{!Qn:-Qy} %{n} %{T} %{Ym,*} %{Yd,*} %{Wa,*:%*}" |
---|
101 | |
---|
102 | /* svr4 assemblers need the `-' (indicating input from stdin) to come after |
---|
103 | the -o option (and its argument) for some reason. If we try to put it |
---|
104 | before the -o option, the assembler will try to read the file named as |
---|
105 | the output file in the -o option as an input file (after it has already |
---|
106 | written some stuff to it) and the binary stuff contained therein will |
---|
107 | cause totally confuse the assembler, resulting in many spurious error |
---|
108 | messages. */ |
---|
109 | |
---|
110 | #undef ASM_FINAL_SPEC |
---|
111 | #define ASM_FINAL_SPEC "%{pipe:-}" |
---|
112 | |
---|
113 | /* Under svr4, the normal location of the `ld' and `as' programs is the |
---|
114 | /usr/ccs/bin directory. */ |
---|
115 | |
---|
116 | #undef MD_EXEC_PREFIX |
---|
117 | #define MD_EXEC_PREFIX "/usr/ccs/bin/" |
---|
118 | |
---|
119 | /* Under svr4, the normal location of the various *crt*.o files is the |
---|
120 | /usr/ccs/lib directory. */ |
---|
121 | |
---|
122 | #undef MD_STARTFILE_PREFIX |
---|
123 | #define MD_STARTFILE_PREFIX "/usr/ccs/lib/" |
---|
124 | |
---|
125 | /* Provide a LIB_SPEC appropriate for svr4. Here we tack on the default |
---|
126 | standard C library (unless we are building a shared library). */ |
---|
127 | |
---|
128 | #undef LIB_SPEC |
---|
129 | #define LIB_SPEC "%{!shared:%{!symbolic:-lc}}" |
---|
130 | |
---|
131 | /* Provide a LIBGCC_SPEC appropriate for svr4. We also want to exclude |
---|
132 | libgcc when -symbolic. */ |
---|
133 | |
---|
134 | #undef LIBGCC_SPEC |
---|
135 | #define LIBGCC_SPEC "%{!shared:%{!symbolic:-lgcc}}" |
---|
136 | |
---|
137 | /* Provide an ENDFILE_SPEC appropriate for svr4. Here we tack on our own |
---|
138 | magical crtend.o file (see crtstuff.c) which provides part of the |
---|
139 | support for getting C++ file-scope static object constructed before |
---|
140 | entering `main', followed by the normal svr3/svr4 "finalizer" file, |
---|
141 | which is either `gcrtn.o' or `crtn.o'. */ |
---|
142 | |
---|
143 | #undef ENDFILE_SPEC |
---|
144 | #define ENDFILE_SPEC "crtend.o%s %{pg:gcrtn.o}%{!pg:crtn.o%s}" |
---|
145 | |
---|
146 | /* Provide a LINK_SPEC appropriate for svr4. Here we provide support |
---|
147 | for the special GCC options -static, -shared, and -symbolic which |
---|
148 | allow us to link things in one of these three modes by applying the |
---|
149 | appropriate combinations of options at link-time. We also provide |
---|
150 | support here for as many of the other svr4 linker options as seems |
---|
151 | reasonable, given that some of them conflict with options for other |
---|
152 | svr4 tools (e.g. the assembler). In particular, we do support the |
---|
153 | -h*, -z*, -V, -b, -t, -Qy, -Qn, and -YP* options here, and the -e*, |
---|
154 | -l*, -o*, -r, -s, -u*, and -L* options are directly supported |
---|
155 | by gcc.c itself. We don't directly support the -m (generate load |
---|
156 | map) option because that conflicts with the -m (run m4) option of |
---|
157 | the svr4 assembler. We also don't directly support the svr4 linker's |
---|
158 | -I* or -M* options because these conflict with existing GCC options. |
---|
159 | We do however allow passing arbitrary options to the svr4 linker |
---|
160 | via the -Wl, option. We don't support the svr4 linker's -a option |
---|
161 | at all because it is totally useless and because it conflicts with |
---|
162 | GCC's own -a option. |
---|
163 | |
---|
164 | Note that gcc doesn't allow a space to follow -Y in a -YP,* option. |
---|
165 | |
---|
166 | When the -G link option is used (-shared and -symbolic) a final link is |
---|
167 | not being done. */ |
---|
168 | |
---|
169 | #undef LINK_SPEC |
---|
170 | #define LINK_SPEC "%{h*} %{V} %{v:%{!V:-V}} \ |
---|
171 | %{b} %{Wl,*:%*} \ |
---|
172 | %{static:-dn -Bstatic} \ |
---|
173 | %{shared:-G -dy -z text %{!h*:%{o*:-h %*}}} \ |
---|
174 | %{symbolic:-Bsymbolic -G -dy -z text %{!h*:%{o*:-h %*}}} \ |
---|
175 | %{G:-G} \ |
---|
176 | %{YP,*} \ |
---|
177 | %{!YP,*:%{p:-Y P,/usr/ccs/lib/libp:/usr/lib/libp:/usr/ccs/lib:/usr/lib} \ |
---|
178 | %{!p:-Y P,/usr/ccs/lib:/usr/lib}} \ |
---|
179 | %{Qy:} %{!Qn:-Qy}" |
---|
180 | |
---|
181 | /* Gcc automatically adds in one of the files /usr/ccs/lib/values-Xc.o, |
---|
182 | /usr/ccs/lib/values-Xa.o, or /usr/ccs/lib/values-Xt.o for each final |
---|
183 | link step (depending upon the other gcc options selected, such as |
---|
184 | -traditional and -ansi). These files each contain one (initialized) |
---|
185 | copy of a special variable called `_lib_version'. Each one of these |
---|
186 | files has `_lib_version' initialized to a different (enum) value. |
---|
187 | The SVR4 library routines query the value of `_lib_version' at run |
---|
188 | to decide how they should behave. Specifically, they decide (based |
---|
189 | upon the value of `_lib_version') if they will act in a strictly ANSI |
---|
190 | conforming manner or not. |
---|
191 | */ |
---|
192 | |
---|
193 | #undef STARTFILE_SPEC |
---|
194 | #define STARTFILE_SPEC "%{!shared: \ |
---|
195 | %{!symbolic: \ |
---|
196 | %{pg:gcrt1.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}}}}\ |
---|
197 | %{pg:gcrti.o%s}%{!pg:crti.o%s} \ |
---|
198 | %{ansi:values-Xc.o%s} \ |
---|
199 | %{!ansi: \ |
---|
200 | %{traditional:values-Xt.o%s} \ |
---|
201 | %{!traditional:values-Xa.o%s}} \ |
---|
202 | crtbegin.o%s" |
---|
203 | |
---|
204 | /* Attach a special .ident directive to the end of the file to identify |
---|
205 | the version of GCC which compiled this code. The format of the |
---|
206 | .ident string is patterned after the ones produced by native svr4 |
---|
207 | C compilers. */ |
---|
208 | |
---|
209 | #define IDENT_ASM_OP ".ident" |
---|
210 | |
---|
211 | #define ASM_FILE_END(FILE) \ |
---|
212 | do { \ |
---|
213 | fprintf ((FILE), "\t%s\t\"GCC: (GNU) %s\"\n", \ |
---|
214 | IDENT_ASM_OP, version_string); \ |
---|
215 | } while (0) |
---|
216 | |
---|
217 | /* Allow #sccs in preprocessor. */ |
---|
218 | |
---|
219 | #define SCCS_DIRECTIVE |
---|
220 | |
---|
221 | /* Output #ident as a .ident. */ |
---|
222 | |
---|
223 | #define ASM_OUTPUT_IDENT(FILE, NAME) \ |
---|
224 | fprintf (FILE, "\t%s\t\"%s\"\n", IDENT_ASM_OP, NAME); |
---|
225 | |
---|
226 | /* Use periods rather than dollar signs in special g++ assembler names. */ |
---|
227 | |
---|
228 | #define NO_DOLLAR_IN_LABEL |
---|
229 | |
---|
230 | /* Writing `int' for a bitfield forces int alignment for the structure. */ |
---|
231 | |
---|
232 | #define PCC_BITFIELD_TYPE_MATTERS 1 |
---|
233 | |
---|
234 | /* Implicit library calls should use memcpy, not bcopy, etc. */ |
---|
235 | |
---|
236 | #define TARGET_MEM_FUNCTIONS |
---|
237 | |
---|
238 | /* Handle #pragma weak and #pragma pack. */ |
---|
239 | |
---|
240 | #define HANDLE_SYSV_PRAGMA |
---|
241 | |
---|
242 | /* System V Release 4 uses DWARF debugging info. */ |
---|
243 | |
---|
244 | #define DWARF_DEBUGGING_INFO |
---|
245 | |
---|
246 | /* The numbers used to denote specific machine registers in the System V |
---|
247 | Release 4 DWARF debugging information are quite likely to be totally |
---|
248 | different from the numbers used in BSD stabs debugging information |
---|
249 | for the same kind of target machine. Thus, we undefine the macro |
---|
250 | DBX_REGISTER_NUMBER here as an extra inducement to get people to |
---|
251 | provide proper machine-specific definitions of DBX_REGISTER_NUMBER |
---|
252 | (which is also used to provide DWARF registers numbers in dwarfout.c) |
---|
253 | in their tm.h files which include this file. */ |
---|
254 | |
---|
255 | #undef DBX_REGISTER_NUMBER |
---|
256 | |
---|
257 | /* gas on SVR4 supports the use of .stabs. Permit -gstabs to be used |
---|
258 | in general, although it will only work when using gas. */ |
---|
259 | |
---|
260 | #define DBX_DEBUGGING_INFO |
---|
261 | |
---|
262 | /* Use DWARF debugging info by default. */ |
---|
263 | |
---|
264 | #ifndef PREFERRED_DEBUGGING_TYPE |
---|
265 | #define PREFERRED_DEBUGGING_TYPE DWARF_DEBUG |
---|
266 | #endif |
---|
267 | |
---|
268 | /* Make LBRAC and RBRAC addresses relative to the start of the |
---|
269 | function. The native Solaris stabs debugging format works this |
---|
270 | way, gdb expects it, and it reduces the number of relocation |
---|
271 | entries. */ |
---|
272 | |
---|
273 | #define DBX_BLOCKS_FUNCTION_RELATIVE 1 |
---|
274 | |
---|
275 | /* When using stabs, gcc2_compiled must be a stabs entry, not an |
---|
276 | ordinary symbol, or gdb won't see it. Furthermore, since gdb reads |
---|
277 | the input piecemeal, starting with each N_SO, it's a lot easier if |
---|
278 | the gcc2 flag symbol is *after* the N_SO rather than before it. So |
---|
279 | we emit an N_OPT stab there. */ |
---|
280 | |
---|
281 | #define ASM_IDENTIFY_GCC(FILE) \ |
---|
282 | do \ |
---|
283 | { \ |
---|
284 | if (write_symbols != DBX_DEBUG) \ |
---|
285 | fputs ("gcc2_compiled.:\n", FILE); \ |
---|
286 | } \ |
---|
287 | while (0) |
---|
288 | |
---|
289 | #define ASM_IDENTIFY_GCC_AFTER_SOURCE(FILE) \ |
---|
290 | do \ |
---|
291 | { \ |
---|
292 | if (write_symbols == DBX_DEBUG) \ |
---|
293 | fputs ("\t.stabs\t\"gcc2_compiled.\", 0x3c, 0, 0, 0\n", FILE); \ |
---|
294 | } \ |
---|
295 | while (0) |
---|
296 | |
---|
297 | /* Like block addresses, stabs line numbers are relative to the |
---|
298 | current function. */ |
---|
299 | |
---|
300 | #define ASM_OUTPUT_SOURCE_LINE(file, line) \ |
---|
301 | do \ |
---|
302 | { \ |
---|
303 | static int sym_lineno = 1; \ |
---|
304 | fprintf (file, ".stabn 68,0,%d,.LM%d-", \ |
---|
305 | line, sym_lineno); \ |
---|
306 | assemble_name (file, \ |
---|
307 | XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\ |
---|
308 | fprintf (file, "\n.LM%d:\n", sym_lineno); \ |
---|
309 | sym_lineno += 1; \ |
---|
310 | } \ |
---|
311 | while (0) |
---|
312 | |
---|
313 | /* In order for relative line numbers to work, we must output the |
---|
314 | stabs entry for the function name first. */ |
---|
315 | |
---|
316 | #define DBX_FUNCTION_FIRST |
---|
317 | |
---|
318 | /* Generate a blank trailing N_SO to mark the end of the .o file, since |
---|
319 | we can't depend upon the linker to mark .o file boundaries with |
---|
320 | embedded stabs. */ |
---|
321 | |
---|
322 | #define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \ |
---|
323 | fprintf (FILE, \ |
---|
324 | "\t.text\n\t.stabs \"\",%d,0,0,.Letext\n.Letext:\n", N_SO) |
---|
325 | |
---|
326 | /* Define the actual types of some ANSI-mandated types. (These |
---|
327 | definitions should work for most SVR4 systems). */ |
---|
328 | |
---|
329 | #undef SIZE_TYPE |
---|
330 | #define SIZE_TYPE "unsigned int" |
---|
331 | |
---|
332 | #undef PTRDIFF_TYPE |
---|
333 | #define PTRDIFF_TYPE "int" |
---|
334 | |
---|
335 | #undef WCHAR_TYPE |
---|
336 | #define WCHAR_TYPE "long int" |
---|
337 | |
---|
338 | #undef WCHAR_TYPE_SIZE |
---|
339 | #define WCHAR_TYPE_SIZE BITS_PER_WORD |
---|
340 | |
---|
341 | /* This causes trouble, because it requires the host machine |
---|
342 | to support ANSI C. */ |
---|
343 | /* #define MULTIBYTE_CHARS */ |
---|
344 | |
---|
345 | #undef ASM_BYTE_OP |
---|
346 | #define ASM_BYTE_OP ".byte" |
---|
347 | |
---|
348 | #undef SET_ASM_OP |
---|
349 | #define SET_ASM_OP ".set" |
---|
350 | |
---|
351 | /* This is how to begin an assembly language file. Most svr4 assemblers want |
---|
352 | at least a .file directive to come first, and some want to see a .version |
---|
353 | directive come right after that. Here we just establish a default |
---|
354 | which generates only the .file directive. If you need a .version |
---|
355 | directive for any specific target, you should override this definition |
---|
356 | in the target-specific file which includes this one. */ |
---|
357 | |
---|
358 | #undef ASM_FILE_START |
---|
359 | #define ASM_FILE_START(FILE) \ |
---|
360 | output_file_directive ((FILE), main_input_filename) |
---|
361 | |
---|
362 | /* This is how to allocate empty space in some section. The .zero |
---|
363 | pseudo-op is used for this on most svr4 assemblers. */ |
---|
364 | |
---|
365 | #define SKIP_ASM_OP ".zero" |
---|
366 | |
---|
367 | #undef ASM_OUTPUT_SKIP |
---|
368 | #define ASM_OUTPUT_SKIP(FILE,SIZE) \ |
---|
369 | fprintf (FILE, "\t%s\t%u\n", SKIP_ASM_OP, (SIZE)) |
---|
370 | |
---|
371 | /* This is how to output a reference to a user-level label named NAME. |
---|
372 | `assemble_name' uses this. |
---|
373 | |
---|
374 | For System V Release 4 the convention is *not* to prepend a leading |
---|
375 | underscore onto user-level symbol names. */ |
---|
376 | |
---|
377 | #undef ASM_OUTPUT_LABELREF |
---|
378 | #define ASM_OUTPUT_LABELREF(FILE,NAME) fprintf (FILE, "%s", NAME) |
---|
379 | |
---|
380 | /* This is how to output an internal numbered label where |
---|
381 | PREFIX is the class of label and NUM is the number within the class. |
---|
382 | |
---|
383 | For most svr4 systems, the convention is that any symbol which begins |
---|
384 | with a period is not put into the linker symbol table by the assembler. */ |
---|
385 | |
---|
386 | #undef ASM_OUTPUT_INTERNAL_LABEL |
---|
387 | #define ASM_OUTPUT_INTERNAL_LABEL(FILE, PREFIX, NUM) \ |
---|
388 | do { \ |
---|
389 | fprintf (FILE, ".%s%d:\n", PREFIX, NUM); \ |
---|
390 | } while (0) |
---|
391 | |
---|
392 | /* This is how to store into the string LABEL |
---|
393 | the symbol_ref name of an internal numbered label where |
---|
394 | PREFIX is the class of label and NUM is the number within the class. |
---|
395 | This is suitable for output with `assemble_name'. |
---|
396 | |
---|
397 | For most svr4 systems, the convention is that any symbol which begins |
---|
398 | with a period is not put into the linker symbol table by the assembler. */ |
---|
399 | |
---|
400 | #undef ASM_GENERATE_INTERNAL_LABEL |
---|
401 | #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \ |
---|
402 | do { \ |
---|
403 | sprintf (LABEL, "*.%s%d", PREFIX, NUM); \ |
---|
404 | } while (0) |
---|
405 | |
---|
406 | /* Output the label which precedes a jumptable. Note that for all svr4 |
---|
407 | systems where we actually generate jumptables (which is to say every |
---|
408 | svr4 target except i386, where we use casesi instead) we put the jump- |
---|
409 | tables into the .rodata section and since other stuff could have been |
---|
410 | put into the .rodata section prior to any given jumptable, we have to |
---|
411 | make sure that the location counter for the .rodata section gets pro- |
---|
412 | perly re-aligned prior to the actual beginning of the jump table. */ |
---|
413 | |
---|
414 | #define ALIGN_ASM_OP ".align" |
---|
415 | |
---|
416 | #ifndef ASM_OUTPUT_BEFORE_CASE_LABEL |
---|
417 | #define ASM_OUTPUT_BEFORE_CASE_LABEL(FILE,PREFIX,NUM,TABLE) \ |
---|
418 | ASM_OUTPUT_ALIGN ((FILE), 2); |
---|
419 | #endif |
---|
420 | |
---|
421 | #undef ASM_OUTPUT_CASE_LABEL |
---|
422 | #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,JUMPTABLE) \ |
---|
423 | do { \ |
---|
424 | ASM_OUTPUT_BEFORE_CASE_LABEL (FILE, PREFIX, NUM, JUMPTABLE) \ |
---|
425 | ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM); \ |
---|
426 | } while (0) |
---|
427 | |
---|
428 | /* The standard SVR4 assembler seems to require that certain builtin |
---|
429 | library routines (e.g. .udiv) be explicitly declared as .globl |
---|
430 | in each assembly file where they are referenced. */ |
---|
431 | |
---|
432 | #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN) \ |
---|
433 | ASM_GLOBALIZE_LABEL (FILE, XSTR (FUN, 0)) |
---|
434 | |
---|
435 | /* This says how to output assembler code to declare an |
---|
436 | uninitialized external linkage data object. Under SVR4, |
---|
437 | the linker seems to want the alignment of data objects |
---|
438 | to depend on their types. We do exactly that here. */ |
---|
439 | |
---|
440 | #define COMMON_ASM_OP ".comm" |
---|
441 | |
---|
442 | #undef ASM_OUTPUT_ALIGNED_COMMON |
---|
443 | #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN) \ |
---|
444 | do { \ |
---|
445 | fprintf ((FILE), "\t%s\t", COMMON_ASM_OP); \ |
---|
446 | assemble_name ((FILE), (NAME)); \ |
---|
447 | fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT); \ |
---|
448 | } while (0) |
---|
449 | |
---|
450 | /* This says how to output assembler code to declare an |
---|
451 | uninitialized internal linkage data object. Under SVR4, |
---|
452 | the linker seems to want the alignment of data objects |
---|
453 | to depend on their types. We do exactly that here. */ |
---|
454 | |
---|
455 | #define LOCAL_ASM_OP ".local" |
---|
456 | |
---|
457 | #undef ASM_OUTPUT_ALIGNED_LOCAL |
---|
458 | #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN) \ |
---|
459 | do { \ |
---|
460 | fprintf ((FILE), "\t%s\t", LOCAL_ASM_OP); \ |
---|
461 | assemble_name ((FILE), (NAME)); \ |
---|
462 | fprintf ((FILE), "\n"); \ |
---|
463 | ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN); \ |
---|
464 | } while (0) |
---|
465 | |
---|
466 | /* This is the pseudo-op used to generate a 32-bit word of data with a |
---|
467 | specific value in some section. This is the same for all known svr4 |
---|
468 | assemblers. */ |
---|
469 | |
---|
470 | #define INT_ASM_OP ".long" |
---|
471 | |
---|
472 | /* This is the pseudo-op used to generate a contiguous sequence of byte |
---|
473 | values from a double-quoted string WITHOUT HAVING A TERMINATING NUL |
---|
474 | AUTOMATICALLY APPENDED. This is the same for most svr4 assemblers. */ |
---|
475 | |
---|
476 | #undef ASCII_DATA_ASM_OP |
---|
477 | #define ASCII_DATA_ASM_OP ".ascii" |
---|
478 | |
---|
479 | /* Support const sections and the ctors and dtors sections for g++. |
---|
480 | Note that there appears to be two different ways to support const |
---|
481 | sections at the moment. You can either #define the symbol |
---|
482 | READONLY_DATA_SECTION (giving it some code which switches to the |
---|
483 | readonly data section) or else you can #define the symbols |
---|
484 | EXTRA_SECTIONS, EXTRA_SECTION_FUNCTIONS, SELECT_SECTION, and |
---|
485 | SELECT_RTX_SECTION. We do both here just to be on the safe side. */ |
---|
486 | |
---|
487 | #define USE_CONST_SECTION 1 |
---|
488 | |
---|
489 | #define CONST_SECTION_ASM_OP ".section\t.rodata" |
---|
490 | |
---|
491 | /* Define the pseudo-ops used to switch to the .ctors and .dtors sections. |
---|
492 | |
---|
493 | Note that we want to give these sections the SHF_WRITE attribute |
---|
494 | because these sections will actually contain data (i.e. tables of |
---|
495 | addresses of functions in the current root executable or shared library |
---|
496 | file) and, in the case of a shared library, the relocatable addresses |
---|
497 | will have to be properly resolved/relocated (and then written into) by |
---|
498 | the dynamic linker when it actually attaches the given shared library |
---|
499 | to the executing process. (Note that on SVR4, you may wish to use the |
---|
500 | `-z text' option to the ELF linker, when building a shared library, as |
---|
501 | an additional check that you are doing everything right. But if you do |
---|
502 | use the `-z text' option when building a shared library, you will get |
---|
503 | errors unless the .ctors and .dtors sections are marked as writable |
---|
504 | via the SHF_WRITE attribute.) */ |
---|
505 | |
---|
506 | #define CTORS_SECTION_ASM_OP ".section\t.ctors,\"aw\"" |
---|
507 | #define DTORS_SECTION_ASM_OP ".section\t.dtors,\"aw\"" |
---|
508 | |
---|
509 | /* On svr4, we *do* have support for the .init and .fini sections, and we |
---|
510 | can put stuff in there to be executed before and after `main'. We let |
---|
511 | crtstuff.c and other files know this by defining the following symbols. |
---|
512 | The definitions say how to change sections to the .init and .fini |
---|
513 | sections. This is the same for all known svr4 assemblers. */ |
---|
514 | |
---|
515 | #define INIT_SECTION_ASM_OP ".section\t.init" |
---|
516 | #define FINI_SECTION_ASM_OP ".section\t.fini" |
---|
517 | |
---|
518 | /* A default list of other sections which we might be "in" at any given |
---|
519 | time. For targets that use additional sections (e.g. .tdesc) you |
---|
520 | should override this definition in the target-specific file which |
---|
521 | includes this file. */ |
---|
522 | |
---|
523 | #undef EXTRA_SECTIONS |
---|
524 | #define EXTRA_SECTIONS in_const, in_ctors, in_dtors |
---|
525 | |
---|
526 | /* A default list of extra section function definitions. For targets |
---|
527 | that use additional sections (e.g. .tdesc) you should override this |
---|
528 | definition in the target-specific file which includes this file. */ |
---|
529 | |
---|
530 | #undef EXTRA_SECTION_FUNCTIONS |
---|
531 | #define EXTRA_SECTION_FUNCTIONS \ |
---|
532 | CONST_SECTION_FUNCTION \ |
---|
533 | CTORS_SECTION_FUNCTION \ |
---|
534 | DTORS_SECTION_FUNCTION |
---|
535 | |
---|
536 | #define READONLY_DATA_SECTION() const_section () |
---|
537 | |
---|
538 | extern void text_section (); |
---|
539 | |
---|
540 | #define CONST_SECTION_FUNCTION \ |
---|
541 | void \ |
---|
542 | const_section () \ |
---|
543 | { \ |
---|
544 | if (!USE_CONST_SECTION) \ |
---|
545 | text_section(); \ |
---|
546 | else if (in_section != in_const) \ |
---|
547 | { \ |
---|
548 | fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP); \ |
---|
549 | in_section = in_const; \ |
---|
550 | } \ |
---|
551 | } |
---|
552 | |
---|
553 | #define CTORS_SECTION_FUNCTION \ |
---|
554 | void \ |
---|
555 | ctors_section () \ |
---|
556 | { \ |
---|
557 | if (in_section != in_ctors) \ |
---|
558 | { \ |
---|
559 | fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP); \ |
---|
560 | in_section = in_ctors; \ |
---|
561 | } \ |
---|
562 | } |
---|
563 | |
---|
564 | #define DTORS_SECTION_FUNCTION \ |
---|
565 | void \ |
---|
566 | dtors_section () \ |
---|
567 | { \ |
---|
568 | if (in_section != in_dtors) \ |
---|
569 | { \ |
---|
570 | fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP); \ |
---|
571 | in_section = in_dtors; \ |
---|
572 | } \ |
---|
573 | } |
---|
574 | |
---|
575 | /* Switch into a generic section. |
---|
576 | This is currently only used to support section attributes. |
---|
577 | |
---|
578 | We make the section read-only and executable for a function decl, |
---|
579 | read-only for a const data decl, and writable for a non-const data decl. */ |
---|
580 | #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME) \ |
---|
581 | fprintf (FILE, ".section\t%s,\"%s\",@progbits\n", NAME, \ |
---|
582 | (DECL) && TREE_CODE (DECL) == FUNCTION_DECL ? "ax" : \ |
---|
583 | (DECL) && TREE_READONLY (DECL) ? "a" : "aw") |
---|
584 | |
---|
585 | |
---|
586 | /* A C statement (sans semicolon) to output an element in the table of |
---|
587 | global constructors. */ |
---|
588 | #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \ |
---|
589 | do { \ |
---|
590 | ctors_section (); \ |
---|
591 | fprintf (FILE, "\t%s\t ", INT_ASM_OP); \ |
---|
592 | assemble_name (FILE, NAME); \ |
---|
593 | fprintf (FILE, "\n"); \ |
---|
594 | } while (0) |
---|
595 | |
---|
596 | /* A C statement (sans semicolon) to output an element in the table of |
---|
597 | global destructors. */ |
---|
598 | #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \ |
---|
599 | do { \ |
---|
600 | dtors_section (); \ |
---|
601 | fprintf (FILE, "\t%s\t ", INT_ASM_OP); \ |
---|
602 | assemble_name (FILE, NAME); \ |
---|
603 | fprintf (FILE, "\n"); \ |
---|
604 | } while (0) |
---|
605 | |
---|
606 | /* A C statement or statements to switch to the appropriate |
---|
607 | section for output of DECL. DECL is either a `VAR_DECL' node |
---|
608 | or a constant of some sort. RELOC indicates whether forming |
---|
609 | the initial value of DECL requires link-time relocations. */ |
---|
610 | |
---|
611 | #define SELECT_SECTION(DECL,RELOC) \ |
---|
612 | { \ |
---|
613 | if (TREE_CODE (DECL) == STRING_CST) \ |
---|
614 | { \ |
---|
615 | if (! flag_writable_strings) \ |
---|
616 | const_section (); \ |
---|
617 | else \ |
---|
618 | data_section (); \ |
---|
619 | } \ |
---|
620 | else if (TREE_CODE (DECL) == VAR_DECL) \ |
---|
621 | { \ |
---|
622 | if ((flag_pic && RELOC) \ |
---|
623 | || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL) \ |
---|
624 | || !DECL_INITIAL (DECL) \ |
---|
625 | || (DECL_INITIAL (DECL) != error_mark_node \ |
---|
626 | && !TREE_CONSTANT (DECL_INITIAL (DECL)))) \ |
---|
627 | data_section (); \ |
---|
628 | else \ |
---|
629 | const_section (); \ |
---|
630 | } \ |
---|
631 | else \ |
---|
632 | const_section (); \ |
---|
633 | } |
---|
634 | |
---|
635 | /* A C statement or statements to switch to the appropriate |
---|
636 | section for output of RTX in mode MODE. RTX is some kind |
---|
637 | of constant in RTL. The argument MODE is redundant except |
---|
638 | in the case of a `const_int' rtx. Currently, these always |
---|
639 | go into the const section. */ |
---|
640 | |
---|
641 | #undef SELECT_RTX_SECTION |
---|
642 | #define SELECT_RTX_SECTION(MODE,RTX) const_section() |
---|
643 | |
---|
644 | /* Define the strings used for the special svr4 .type and .size directives. |
---|
645 | These strings generally do not vary from one system running svr4 to |
---|
646 | another, but if a given system (e.g. m88k running svr) needs to use |
---|
647 | different pseudo-op names for these, they may be overridden in the |
---|
648 | file which includes this one. */ |
---|
649 | |
---|
650 | #define TYPE_ASM_OP ".type" |
---|
651 | #define SIZE_ASM_OP ".size" |
---|
652 | |
---|
653 | /* This is how we tell the assembler that a symbol is weak. */ |
---|
654 | |
---|
655 | #define ASM_WEAKEN_LABEL(FILE,NAME) \ |
---|
656 | do { fputs ("\t.weak\t", FILE); assemble_name (FILE, NAME); \ |
---|
657 | fputc ('\n', FILE); } while (0) |
---|
658 | |
---|
659 | /* The following macro defines the format used to output the second |
---|
660 | operand of the .type assembler directive. Different svr4 assemblers |
---|
661 | expect various different forms for this operand. The one given here |
---|
662 | is just a default. You may need to override it in your machine- |
---|
663 | specific tm.h file (depending upon the particulars of your assembler). */ |
---|
664 | |
---|
665 | #define TYPE_OPERAND_FMT "@%s" |
---|
666 | |
---|
667 | /* Write the extra assembler code needed to declare a function's result. |
---|
668 | Most svr4 assemblers don't require any special declaration of the |
---|
669 | result value, but there are exceptions. */ |
---|
670 | |
---|
671 | #ifndef ASM_DECLARE_RESULT |
---|
672 | #define ASM_DECLARE_RESULT(FILE, RESULT) |
---|
673 | #endif |
---|
674 | |
---|
675 | /* These macros generate the special .type and .size directives which |
---|
676 | are used to set the corresponding fields of the linker symbol table |
---|
677 | entries in an ELF object file under SVR4. These macros also output |
---|
678 | the starting labels for the relevant functions/objects. */ |
---|
679 | |
---|
680 | /* Write the extra assembler code needed to declare a function properly. |
---|
681 | Some svr4 assemblers need to also have something extra said about the |
---|
682 | function's return value. We allow for that here. */ |
---|
683 | |
---|
684 | #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \ |
---|
685 | do { \ |
---|
686 | fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \ |
---|
687 | assemble_name (FILE, NAME); \ |
---|
688 | putc (',', FILE); \ |
---|
689 | fprintf (FILE, TYPE_OPERAND_FMT, "function"); \ |
---|
690 | putc ('\n', FILE); \ |
---|
691 | ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL)); \ |
---|
692 | ASM_OUTPUT_LABEL(FILE, NAME); \ |
---|
693 | } while (0) |
---|
694 | |
---|
695 | /* Write the extra assembler code needed to declare an object properly. */ |
---|
696 | |
---|
697 | #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \ |
---|
698 | do { \ |
---|
699 | fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \ |
---|
700 | assemble_name (FILE, NAME); \ |
---|
701 | putc (',', FILE); \ |
---|
702 | fprintf (FILE, TYPE_OPERAND_FMT, "object"); \ |
---|
703 | putc ('\n', FILE); \ |
---|
704 | size_directive_output = 0; \ |
---|
705 | if (!flag_inhibit_size_directive && DECL_SIZE (DECL)) \ |
---|
706 | { \ |
---|
707 | size_directive_output = 1; \ |
---|
708 | fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ |
---|
709 | assemble_name (FILE, NAME); \ |
---|
710 | fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ |
---|
711 | } \ |
---|
712 | ASM_OUTPUT_LABEL(FILE, NAME); \ |
---|
713 | } while (0) |
---|
714 | |
---|
715 | /* Output the size directive for a decl in rest_of_decl_compilation |
---|
716 | in the case where we did not do so before the initializer. |
---|
717 | Once we find the error_mark_node, we know that the value of |
---|
718 | size_directive_output was set |
---|
719 | by ASM_DECLARE_OBJECT_NAME when it was run for the same decl. */ |
---|
720 | |
---|
721 | #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END) \ |
---|
722 | do { \ |
---|
723 | char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \ |
---|
724 | if (!flag_inhibit_size_directive && DECL_SIZE (DECL) \ |
---|
725 | && ! AT_END && TOP_LEVEL \ |
---|
726 | && DECL_INITIAL (DECL) == error_mark_node \ |
---|
727 | && !size_directive_output) \ |
---|
728 | { \ |
---|
729 | size_directive_output = 1; \ |
---|
730 | fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ |
---|
731 | assemble_name (FILE, name); \ |
---|
732 | fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ |
---|
733 | } \ |
---|
734 | } while (0) |
---|
735 | |
---|
736 | /* This is how to declare the size of a function. */ |
---|
737 | |
---|
738 | #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ |
---|
739 | do { \ |
---|
740 | if (!flag_inhibit_size_directive) \ |
---|
741 | { \ |
---|
742 | char label[256]; \ |
---|
743 | static int labelno; \ |
---|
744 | labelno++; \ |
---|
745 | ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno); \ |
---|
746 | ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno); \ |
---|
747 | fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ |
---|
748 | assemble_name (FILE, (FNAME)); \ |
---|
749 | fprintf (FILE, ","); \ |
---|
750 | assemble_name (FILE, label); \ |
---|
751 | fprintf (FILE, "-"); \ |
---|
752 | assemble_name (FILE, (FNAME)); \ |
---|
753 | putc ('\n', FILE); \ |
---|
754 | } \ |
---|
755 | } while (0) |
---|
756 | |
---|
757 | /* A table of bytes codes used by the ASM_OUTPUT_ASCII and |
---|
758 | ASM_OUTPUT_LIMITED_STRING macros. Each byte in the table |
---|
759 | corresponds to a particular byte value [0..255]. For any |
---|
760 | given byte value, if the value in the corresponding table |
---|
761 | position is zero, the given character can be output directly. |
---|
762 | If the table value is 1, the byte must be output as a \ooo |
---|
763 | octal escape. If the tables value is anything else, then the |
---|
764 | byte value should be output as a \ followed by the value |
---|
765 | in the table. Note that we can use standard UN*X escape |
---|
766 | sequences for many control characters, but we don't use |
---|
767 | \a to represent BEL because some svr4 assemblers (e.g. on |
---|
768 | the i386) don't know about that. Also, we don't use \v |
---|
769 | since some versions of gas, such as 2.2 did not accept it. */ |
---|
770 | |
---|
771 | #define ESCAPES \ |
---|
772 | "\1\1\1\1\1\1\1\1btn\1fr\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ |
---|
773 | \0\0\"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ |
---|
774 | \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\\0\0\0\ |
---|
775 | \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\ |
---|
776 | \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ |
---|
777 | \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ |
---|
778 | \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ |
---|
779 | \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1" |
---|
780 | |
---|
781 | /* Some svr4 assemblers have a limit on the number of characters which |
---|
782 | can appear in the operand of a .string directive. If your assembler |
---|
783 | has such a limitation, you should define STRING_LIMIT to reflect that |
---|
784 | limit. Note that at least some svr4 assemblers have a limit on the |
---|
785 | actual number of bytes in the double-quoted string, and that they |
---|
786 | count each character in an escape sequence as one byte. Thus, an |
---|
787 | escape sequence like \377 would count as four bytes. |
---|
788 | |
---|
789 | If your target assembler doesn't support the .string directive, you |
---|
790 | should define this to zero. |
---|
791 | */ |
---|
792 | |
---|
793 | #define STRING_LIMIT ((unsigned) 256) |
---|
794 | |
---|
795 | #define STRING_ASM_OP ".string" |
---|
796 | |
---|
797 | /* The routine used to output NUL terminated strings. We use a special |
---|
798 | version of this for most svr4 targets because doing so makes the |
---|
799 | generated assembly code more compact (and thus faster to assemble) |
---|
800 | as well as more readable, especially for targets like the i386 |
---|
801 | (where the only alternative is to output character sequences as |
---|
802 | comma separated lists of numbers). */ |
---|
803 | |
---|
804 | #define ASM_OUTPUT_LIMITED_STRING(FILE, STR) \ |
---|
805 | do \ |
---|
806 | { \ |
---|
807 | register unsigned char *_limited_str = (unsigned char *) (STR); \ |
---|
808 | register unsigned ch; \ |
---|
809 | fprintf ((FILE), "\t%s\t\"", STRING_ASM_OP); \ |
---|
810 | for (; ch = *_limited_str; _limited_str++) \ |
---|
811 | { \ |
---|
812 | register int escape; \ |
---|
813 | switch (escape = ESCAPES[ch]) \ |
---|
814 | { \ |
---|
815 | case 0: \ |
---|
816 | putc (ch, (FILE)); \ |
---|
817 | break; \ |
---|
818 | case 1: \ |
---|
819 | fprintf ((FILE), "\\%03o", ch); \ |
---|
820 | break; \ |
---|
821 | default: \ |
---|
822 | putc ('\\', (FILE)); \ |
---|
823 | putc (escape, (FILE)); \ |
---|
824 | break; \ |
---|
825 | } \ |
---|
826 | } \ |
---|
827 | fprintf ((FILE), "\"\n"); \ |
---|
828 | } \ |
---|
829 | while (0) |
---|
830 | |
---|
831 | /* The routine used to output sequences of byte values. We use a special |
---|
832 | version of this for most svr4 targets because doing so makes the |
---|
833 | generated assembly code more compact (and thus faster to assemble) |
---|
834 | as well as more readable. Note that if we find subparts of the |
---|
835 | character sequence which end with NUL (and which are shorter than |
---|
836 | STRING_LIMIT) we output those using ASM_OUTPUT_LIMITED_STRING. */ |
---|
837 | |
---|
838 | #undef ASM_OUTPUT_ASCII |
---|
839 | #define ASM_OUTPUT_ASCII(FILE, STR, LENGTH) \ |
---|
840 | do \ |
---|
841 | { \ |
---|
842 | register unsigned char *_ascii_bytes = (unsigned char *) (STR); \ |
---|
843 | register unsigned char *limit = _ascii_bytes + (LENGTH); \ |
---|
844 | register unsigned bytes_in_chunk = 0; \ |
---|
845 | for (; _ascii_bytes < limit; _ascii_bytes++) \ |
---|
846 | { \ |
---|
847 | register unsigned char *p; \ |
---|
848 | if (bytes_in_chunk >= 60) \ |
---|
849 | { \ |
---|
850 | fprintf ((FILE), "\"\n"); \ |
---|
851 | bytes_in_chunk = 0; \ |
---|
852 | } \ |
---|
853 | for (p = _ascii_bytes; p < limit && *p != '\0'; p++) \ |
---|
854 | continue; \ |
---|
855 | if (p < limit && (p - _ascii_bytes) <= STRING_LIMIT) \ |
---|
856 | { \ |
---|
857 | if (bytes_in_chunk > 0) \ |
---|
858 | { \ |
---|
859 | fprintf ((FILE), "\"\n"); \ |
---|
860 | bytes_in_chunk = 0; \ |
---|
861 | } \ |
---|
862 | ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes); \ |
---|
863 | _ascii_bytes = p; \ |
---|
864 | } \ |
---|
865 | else \ |
---|
866 | { \ |
---|
867 | register int escape; \ |
---|
868 | register unsigned ch; \ |
---|
869 | if (bytes_in_chunk == 0) \ |
---|
870 | fprintf ((FILE), "\t%s\t\"", ASCII_DATA_ASM_OP); \ |
---|
871 | switch (escape = ESCAPES[ch = *_ascii_bytes]) \ |
---|
872 | { \ |
---|
873 | case 0: \ |
---|
874 | putc (ch, (FILE)); \ |
---|
875 | bytes_in_chunk++; \ |
---|
876 | break; \ |
---|
877 | case 1: \ |
---|
878 | fprintf ((FILE), "\\%03o", ch); \ |
---|
879 | bytes_in_chunk += 4; \ |
---|
880 | break; \ |
---|
881 | default: \ |
---|
882 | putc ('\\', (FILE)); \ |
---|
883 | putc (escape, (FILE)); \ |
---|
884 | bytes_in_chunk += 2; \ |
---|
885 | break; \ |
---|
886 | } \ |
---|
887 | } \ |
---|
888 | } \ |
---|
889 | if (bytes_in_chunk > 0) \ |
---|
890 | fprintf ((FILE), "\"\n"); \ |
---|
891 | } \ |
---|
892 | while (0) |
---|
893 | |
---|
894 | /* All SVR4 targets use the ELF object file format. */ |
---|
895 | #define OBJECT_FORMAT_ELF |
---|