File:  [DragonFly] / src / contrib / gcc / config / i386 / Attic / freebsd.h.fixed
Revision 1.2: download - view: text, annotated - select for diffs
Tue Jun 17 04:24:01 2003 UTC (11 years, 2 months ago) by dillon
Branches: MAIN
CVS tags: HEAD
Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids.  Most
ids have been removed from !lint sections and moved into comment sections.

    1: /* Definitions for Intel 386 running FreeBSD with either a.out or ELF format
    2:    Copyright (C) 1996-2000 Free Software Foundation, Inc.
    3:    Contributed by Eric Youngdale.
    4:    Modified for stabs-in-ELF by H.J. Lu.
    5:    Adapted from GNU/Linux version by John Polstra.
    6:    Added support for generating "old a.out gas" on the fly by Peter Wemm.
    7:    Continued development by David O'Brien <obrien@freebsd.org>
    8: 
    9: This file is part of GNU CC.
   10: 
   11: GNU CC is free software; you can redistribute it and/or modify
   12: it under the terms of the GNU General Public License as published by
   13: the Free Software Foundation; either version 2, or (at your option)
   14: any later version.
   15: 
   16: GNU CC is distributed in the hope that it will be useful,
   17: but WITHOUT ANY WARRANTY; without even the implied warranty of
   18: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   19: GNU General Public License for more details.
   20: 
   21: You should have received a copy of the GNU General Public License
   22: along with GNU CC; see the file COPYING.  If not, write to
   23: the Free Software Foundation, 59 Temple Place - Suite 330,
   24: Boston, MA 02111-1307, USA.  */
   25: 
   26: /* $FreeBSD: src/contrib/gcc/config/i386/freebsd.h.fixed,v 1.34.2.3 2001/03/02 09:27:49 obrien Exp $ */
   27: /* $DragonFly: src/contrib/gcc/config/i386/freebsd.h.fixed,v 1.2 2003/06/17 04:24:01 dillon Exp $ */
   28: 
   29: #undef  CPP_PREDEFINES
   30: #define CPP_PREDEFINES 							\
   31:   "-Di386 -Acpu(i386) -Amachine(i386)"					\
   32:   FBSD_CPP_PREDEFINES
   33: 
   34: #undef  CC1_SPEC
   35: #define CC1_SPEC "\
   36:   %{gline:%{!g:%{!g0:%{!g1:%{!g2: -g1}}}}} \
   37:   %{maout: %{!mno-underscores: %{!munderscores: -munderscores }}}"
   38: 
   39: #undef  ASM_SPEC
   40: #define ASM_SPEC	"%{v*: -v} %{maout: %{fpic:-k} %{fPIC:-k}}"
   41: 
   42: #undef  ASM_FINAL_SPEC 
   43: #define ASM_FINAL_SPEC	"%|"
   44: 
   45: /* Provide a LINK_SPEC appropriate for FreeBSD.  Here we provide support
   46:    for the special GCC options -static and -shared, which allow us to
   47:    link things in one of these three modes by applying the appropriate
   48:    combinations of options at link-time. We like to support here for
   49:    as many of the other GNU linker options as possible. But I don't
   50:    have the time to search for those flags. I am sure how to add
   51:    support for -soname shared_object_name. H.J.
   52: 
   53:    I took out %{v:%{!V:-V}}. It is too much :-(. They can use
   54:    -Wl,-V.
   55: 
   56:    When the -shared link option is used a final link is not being
   57:    done.  */
   58: 
   59: #undef	LINK_SPEC
   60: #define LINK_SPEC "\
   61:  %{p:%e`-p' not supported; use `-pg' and gprof(1)} \
   62:   %{maout: %{shared:-Bshareable} \
   63:     %{!shared:%{!nostdlib:%{!r:%{!e*:-e start}}} -dc -dp %{static:-Bstatic} \
   64:       %{pg:-Bstatic} %{Z}} \
   65:     %{assert*} %{R*}} \
   66:   %{!maout: \
   67:     -m elf_i386 \
   68:     %{Wl,*:%*} \
   69:     %{assert*} %{R*} %{rpath*} %{defsym*} \
   70:     %{shared:-Bshareable %{h*} %{soname*}} \
   71:     %{symbolic:-Bsymbolic} \
   72:     %{!shared: \
   73:       %{!static: \
   74: 	%{rdynamic: -export-dynamic} \
   75: 	%{!dynamic-linker: -dynamic-linker /usr/libexec/ld-elf.so.1}} \
   76:       %{static:-Bstatic}}}"
   77: 
   78: #undef STARTFILE_SPEC
   79: #define STARTFILE_SPEC "\
   80:   %{maout: %{shared:c++rt0.o%s} \
   81:     %{!shared: \
   82:       %{pg:gcrt0.o%s}%{!pg: \
   83: 	%{static:scrt0.o%s} \
   84: 	%{!static:crt0.o%s}}}} \
   85:   %{!maout: \
   86:     %{!shared: \
   87:       %{pg:gcrt1.o%s} \
   88:       %{!pg: \
   89: 	%{p:gcrt1.o%s} \
   90: 	%{!p:crt1.o%s}}} \
   91:     crti.o%s %{!shared:crtbegin.o%s} %{shared:crtbeginS.o%s}}"
   92: 
   93: /* Provide an ENDFILE_SPEC appropriate for FreeBSD/i386.  Here we tack on our
   94:    own magical crtend.o file (compare w/crtstuff.c) which provides part of the
   95:    support for getting C++ file-scope static object constructed before
   96:    entering `main', followed by the normal "finalizer" file, `crtn.o'.  */
   97: 
   98: #undef  ENDFILE_SPEC
   99: #define ENDFILE_SPEC "\
  100:   %{!maout: \
  101:     %{!shared:crtend.o%s} \
  102:     %{shared:crtendS.o%s} crtn.o%s}"
  103: 
  104: 
  105: /************************[  Target stuff  ]***********************************/
  106: 
  107: /* Define the actual types of some ANSI-mandated types.  
  108:    Needs to agree with <machine/ansi.h>.  GCC defaults come from c-decl.c,
  109:    c-common.c, and config/<arch>/<arch>.h.  */
  110: 
  111: #undef SIZE_TYPE
  112: #define SIZE_TYPE	"unsigned int"
  113:  
  114: #undef PTRDIFF_TYPE
  115: #define PTRDIFF_TYPE	"int"
  116: 
  117: /* This is the pseudo-op used to generate a 32-bit word of data with a
  118:    specific value in some section.  */
  119: 
  120: #undef INT_ASM_OP
  121: #define INT_ASM_OP	".long"
  122: 
  123: /* Biggest alignment supported by the object file format of this
  124:    machine.  Use this macro to limit the alignment which can be
  125:    specified using the `__attribute__ ((aligned (N)))' construct.  If
  126:    not defined, the default value is `BIGGEST_ALIGNMENT'.  */
  127: 
  128: #define MAX_OFILE_ALIGNMENT (32768*8)
  129: 
  130: #undef  TARGET_VERSION
  131: #define TARGET_VERSION	fprintf (stderr, " (i386 FreeBSD/ELF)");
  132: 
  133: #define MASK_PROFILER_EPILOGUE	010000000000
  134: #define MASK_AOUT		004000000000	/* a.out not elf */
  135: #define MASK_UNDERSCORES	002000000000	/* use leading _ */
  136: 
  137: #define TARGET_PROFILER_EPILOGUE	(target_flags & MASK_PROFILER_EPILOGUE)
  138: #define TARGET_AOUT			(target_flags & MASK_AOUT)
  139: #define TARGET_ELF			((target_flags & MASK_AOUT) == 0)
  140: #define TARGET_UNDERSCORES		((target_flags & MASK_UNDERSCORES) != 0)
  141: 
  142: #undef	SUBTARGET_SWITCHES
  143: #define SUBTARGET_SWITCHES						\
  144:   { "profiler-epilogue",	 MASK_PROFILER_EPILOGUE, "Function profiler epilogue"}, \
  145:   { "no-profiler-epilogue",	-MASK_PROFILER_EPILOGUE, "No function profiler epilogue"}, \
  146:   { "aout",			 MASK_AOUT, "Generate an a.out (vs. ELF) binary"}, \
  147:   { "no-aout",			-MASK_AOUT, "Do not generate an a.out binary"}, \
  148:   { "underscores",		 MASK_UNDERSCORES, "Add leading underscores to symbols"}, \
  149:   { "no-underscores",		-MASK_UNDERSCORES, "Do not add leading underscores to symbols"},
  150: 
  151: /* This goes away when the math emulator is fixed.  */
  152: #undef  TARGET_DEFAULT
  153: #define TARGET_DEFAULT \
  154:   (MASK_80387 | MASK_IEEE_FP | MASK_FLOAT_RETURNS | MASK_NO_FANCY_MATH_387)
  155: 
  156: /* Prefix for internally generated assembler labels.  If we aren't using 
  157:    underscores, we are using prefix `.'s to identify labels that should  
  158:    be ignored, as in `i386/gas.h' --karl@cs.umb.edu  */                 
  159: #undef  LPREFIX
  160: #define LPREFIX ((TARGET_UNDERSCORES) ? "L" : ".L")
  161: 
  162: /* The a.out tools do not support "linkonce" sections. */
  163: #undef  SUPPORTS_ONE_ONLY
  164: #define SUPPORTS_ONE_ONLY	TARGET_ELF
  165: 
  166: /* Enable alias attribute support.  */
  167: #undef  SET_ASM_OP
  168: #define SET_ASM_OP		".set"
  169: 
  170: /* The a.out tools do not support "Lscope" .stabs symbols. */
  171: #undef  NO_DBX_FUNCTION_END
  172: #define NO_DBX_FUNCTION_END	TARGET_AOUT
  173: 
  174: /* In ELF, the function stabs come first, before the relative offsets.  */
  175: #undef  DBX_FUNCTION_FIRST
  176: #define DBX_CHECK_FUNCTION_FIRST TARGET_ELF
  177: 
  178: /* supply our own hook for calling __main() from main() */
  179: #undef  INVOKE__main
  180: #define INVOKE__main
  181: #undef  GEN_CALL__MAIN
  182: #define GEN_CALL__MAIN							\
  183:   do {									\
  184:     if (!(TARGET_ELF))							\
  185:       emit_library_call (gen_rtx (SYMBOL_REF, Pmode, NAME__MAIN), 0,	\
  186: 			 VOIDmode, 0);					\
  187:   } while (0)
  188: 
  189: /* Indicate that jump tables go in the text section.  This is
  190:    necessary when compiling PIC code.  */
  191: #undef  JUMP_TABLES_IN_TEXT_SECTION
  192: #define JUMP_TABLES_IN_TEXT_SECTION	(flag_pic)
  193: 
  194: /* override the exception table positioning */
  195: #undef  EXCEPTION_SECTION
  196: #define EXCEPTION_SECTION() \
  197:   do {									\
  198:     if (TARGET_ELF)							\
  199:       {									\
  200: 	named_section (NULL_TREE, ".gcc_except_table", 0);		\
  201:       }									\
  202:     else								\
  203:       {									\
  204: 	if (flag_pic)							\
  205: 	  data_section ();						\
  206: 	else								\
  207: 	  readonly_data_section ();					\
  208:       }									\
  209:   } while (0);
  210: 
  211: /* Tell final.c that we don't need a label passed to mcount.  */
  212: #undef  NO_PROFILE_COUNTERS
  213: #define NO_PROFILE_COUNTERS
  214: 
  215: /* Output assembler code to FILE to begin profiling of the current function.
  216:    LABELNO is an optional label.  */
  217: 
  218: #undef  FUNCTION_PROFILER
  219: #define FUNCTION_PROFILER(FILE, LABELNO)  \
  220:   do {									\
  221:     char *_name = TARGET_AOUT ? "mcount" : ".mcount";			\
  222:     if (flag_pic)							\
  223:       fprintf ((FILE), "\tcall *%s@GOT(%%ebx)\n", _name);		\
  224:     else								\
  225:       fprintf ((FILE), "\tcall %s\n", _name);				\
  226:   } while (0)
  227: 
  228: /* Output assembler code to FILE to end profiling of the current function.  */
  229: 
  230: #undef  FUNCTION_PROFILER_EPILOGUE
  231: #define FUNCTION_PROFILER_EPILOGUE(FILE, DO_RTL)			\
  232:   do {									\
  233:     if (TARGET_PROFILER_EPILOGUE)					\
  234:       {									\
  235: 	if (DO_RTL)							\
  236: 	  {								\
  237: 	  /* ".mexitcount" is specially handled in			\
  238: 	     ASM_HACK_SYMBOLREF () so that we don't need to handle	\
  239: 	     flag_pic or TARGET_AOUT here.  */				\
  240: 	    rtx xop;							\
  241: 	    xop = gen_rtx_MEM (FUNCTION_MODE,				\
  242: 			    gen_rtx_SYMBOL_REF (Pmode, ".mexitcount"));	\
  243: 	    emit_call_insn (gen_rtx (CALL, VOIDmode, xop, const0_rtx));	\
  244: 	  }								\
  245: 	else								\
  246: 	  {								\
  247: 	  /* XXX this !DO_RTL case is broken but not actually used.  */	\
  248: 	    char *_name = TARGET_AOUT ? "mcount" : ".mcount";		\
  249: 	    if (flag_pic)						\
  250: 	      fprintf (FILE, "\tcall *%s@GOT(%%ebx)\n", _name);		\
  251: 	    else							\
  252: 	      fprintf (FILE, "\tcall %s\n", _name);			\
  253: 	  }								\
  254:       }									\
  255:   } while (0)
  256: 
  257: 
  258: /************************[  Assembler stuff  ]********************************/
  259: 
  260: #undef  ASM_APP_ON
  261: #define ASM_APP_ON	"#APP\n"
  262: 
  263: #undef  ASM_APP_OFF
  264: #define ASM_APP_OFF	"#NO_APP\n" 
  265: 
  266: /* This is how to begin an assembly language file.
  267:    The .file command should always begin the output.
  268:    ELF also needs a .version.  */
  269: 
  270: #undef  ASM_FILE_START
  271: #define ASM_FILE_START(FILE)						\
  272:   do {									\
  273:     output_file_directive ((FILE), main_input_filename);		\
  274:     if (TARGET_ELF)							\
  275:       fprintf ((FILE), "\t.version\t\"01.01\"\n");			\
  276:   } while (0)
  277: 
  278: /* This is how to store into the string BUF
  279:    the symbol_ref name of an internal numbered label where      
  280:    PREFIX is the class of label and NUM is the number within the class.  
  281:    This is suitable for output with `assemble_name'.  */
  282: #undef	ASM_GENERATE_INTERNAL_LABEL
  283: #define ASM_GENERATE_INTERNAL_LABEL(BUF, PREFIX, NUMBER)		\
  284:   sprintf ((BUF), "*%s%s%d", (TARGET_UNDERSCORES) ? "" : ".",		\
  285: 	   (PREFIX), (NUMBER))
  286: 
  287: /* This is how to output an internal numbered label where
  288:    PREFIX is the class of label and NUM is the number within the class.
  289:    For most svr4/ELF systems, the convention is that any symbol which begins
  290:    with a period is not put into the linker symbol table by the assembler.  */
  291: #undef	ASM_OUTPUT_INTERNAL_LABEL
  292: #define	ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)			\
  293:   fprintf ((FILE), "%s%s%d:\n", (TARGET_UNDERSCORES) ? "" : ".",	\
  294: 	   (PREFIX), (NUM))
  295: 
  296: /* This is how to output a reference to a user-level label named NAME.  */
  297: #undef  ASM_OUTPUT_LABELREF
  298: #define ASM_OUTPUT_LABELREF(FILE, NAME)					\
  299:   do {									\
  300:     char *_name = (NAME);						\
  301:     /* Hack to avoid writing lots of rtl in				\
  302:        FUNCTION_PROFILER_EPILOGUE ().  */				\
  303:     if (*_name == '.' && strcmp(_name + 1, "mexitcount") == 0)		\
  304:       {									\
  305: 	if (TARGET_AOUT)						\
  306: 	  _name++;							\
  307: 	if (flag_pic)							\
  308: 	  fprintf ((FILE), "*%s@GOT(%%ebx)", _name);			\
  309: 	else								\
  310: 	  fprintf ((FILE), "%s", _name);				\
  311:       }									\
  312:     else								\
  313:       fprintf (FILE, "%s%s", TARGET_UNDERSCORES ? "_" : "", _name);	\
  314: } while (0)
  315: 
  316: /* This is how to hack on the symbol code of certain relcalcitrant
  317:    symbols to modify their output in output_pic_addr_const ().  */
  318: 
  319: #undef  ASM_HACK_SYMBOLREF_CODE
  320: #define ASM_HACK_SYMBOLREF_CODE(NAME, CODE)				\
  321:   do {									\
  322:     /* Part of hack to avoid writing lots of rtl in			\
  323:        FUNCTION_PROFILER_EPILOGUE ().  */				\
  324:     char *_name = (NAME);						\
  325:     if (*_name == '.' && strcmp(_name + 1, "mexitcount") == 0)		\
  326:       (CODE) = 'X';							\
  327:   } while (0)
  328: 
  329: /* This is how to output an element of a case-vector that is relative.
  330:    This is only used for PIC code.  See comments by the `casesi' insn in
  331:    i386.md for an explanation of the expression this outputs. */
  332: #undef  ASM_OUTPUT_ADDR_DIFF_ELT
  333: #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)		\
  334:   fprintf ((FILE), "\t.long _GLOBAL_OFFSET_TABLE_+[.-%s%d]\n", LPREFIX, (VALUE))
  335: 
  336: #undef  ASM_OUTPUT_ALIGN
  337: #define ASM_OUTPUT_ALIGN(FILE, LOG)      				\
  338:   if ((LOG)!=0) {							\
  339:     if (in_text_section())						\
  340:       fprintf ((FILE), "\t.p2align %d,0x90\n", (LOG));			\
  341:     else								\
  342:       fprintf ((FILE), "\t.p2align %d\n", (LOG));			\
  343:   }
  344: 
  345: #undef  ASM_OUTPUT_ALIGNED_COMMON
  346: #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)		\
  347:   do {									\
  348:     if (TARGET_ELF)							\
  349:       {									\
  350: 	fprintf ((FILE), "%s", COMMON_ASM_OP);				\
  351: 	assemble_name ((FILE), (NAME));					\
  352: 	fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);	\
  353:       }									\
  354:     else								\
  355:       {									\
  356: 	int rounded = (SIZE);						\
  357: 	if (rounded == 0) rounded = 1;					\
  358: 	rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;		\
  359: 	rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)	\
  360: 		   * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));		\
  361: 	fprintf ((FILE), "%s ", COMMON_ASM_OP);				\
  362: 	assemble_name ((FILE), (NAME));					\
  363: 	fprintf ((FILE), ",%u\n", (rounded));				\
  364:       }									\
  365:   } while (0)
  366: 
  367: /* This says how to output assembler code to declare an
  368:    uninitialized internal linkage data object.  Under SVR4,
  369:    the linker seems to want the alignment of data objects
  370:    to depend on their types.  We do exactly that here.  */
  371: 
  372: #undef  ASM_OUTPUT_ALIGNED_LOCAL
  373: #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)		\
  374:   do {									\
  375:     if (TARGET_ELF)							\
  376:       {									\
  377: 	fprintf ((FILE), "%s", LOCAL_ASM_OP);				\
  378: 	assemble_name ((FILE), (NAME));					\
  379: 	fprintf ((FILE), "\n");						\
  380: 	ASM_OUTPUT_ALIGNED_COMMON ((FILE), (NAME), (SIZE), (ALIGN));	\
  381:       }									\
  382:     else								\
  383:       {									\
  384: 	int rounded = (SIZE);						\
  385: 	if (rounded == 0) rounded = 1;					\
  386: 	rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;		\
  387: 	rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)	\
  388: 		   * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));		\
  389: 	fputs ("\t.lcomm\t", (FILE));					\
  390: 	assemble_name ((FILE), (NAME));					\
  391: 	fprintf ((FILE), ",%u\n", (rounded));				\
  392:       }									\
  393:   } while (0)
  394: 
  395: /* How to output some space.  The rules are different depending on the
  396:    object format.  */
  397: #undef  ASM_OUTPUT_SKIP
  398: #define ASM_OUTPUT_SKIP(FILE, SIZE) 					\
  399:   do {									\
  400:     if (TARGET_ELF)							\
  401:       {									\
  402:         fprintf ((FILE), "%s%u\n", SKIP_ASM_OP, (SIZE));		\
  403:       }									\
  404:     else								\
  405:       {									\
  406:         fprintf ((FILE), "\t.space\t%u\n", (SIZE));			\
  407:       }									\
  408:   } while (0)
  409: 
  410: 
  411: #undef  ASM_OUTPUT_SOURCE_LINE
  412: #define ASM_OUTPUT_SOURCE_LINE(FILE, LINE)				\
  413:   do {									\
  414:     static int sym_lineno = 1;						\
  415:     if (TARGET_ELF)							\
  416:       {									\
  417: 	fprintf ((FILE), ".stabn 68,0,%d,.LM%d-", (LINE), sym_lineno);	\
  418: 	assemble_name ((FILE), 						\
  419: 		XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));	\
  420: 	fprintf ((FILE), "\n.LM%d:\n", sym_lineno);			\
  421: 	sym_lineno += 1;						\
  422:       }									\
  423:     else								\
  424:       {									\
  425: 	fprintf ((FILE), "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE,	\
  426: 		lineno);						\
  427:       }									\
  428:   } while (0)
  429: 
  430: /* These macros generate the special .type and .size directives which
  431:    are used to set the corresponding fields of the linker symbol table
  432:    entries in an ELF object file under SVR4.  These macros also output
  433:    the starting labels for the relevant functions/objects.  */
  434: 
  435: /* Write the extra assembler code needed to declare a function properly.
  436:    Some svr4 assemblers need to also have something extra said about the
  437:    function's return value.  We allow for that here.  */
  438: 
  439: #undef  ASM_DECLARE_FUNCTION_NAME
  440: #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)			\
  441:   do {									\
  442:     fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);				\
  443:     assemble_name (FILE, NAME);						\
  444:     putc (',', FILE);							\
  445:     fprintf (FILE, TYPE_OPERAND_FMT, "function");			\
  446:     putc ('\n', FILE);							\
  447:     ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));			\
  448:     ASM_OUTPUT_LABEL(FILE, NAME);					\
  449:   } while (0)
  450: 
  451: /* This is how to declare the size of a function.  */
  452: 
  453: #undef  ASM_DECLARE_FUNCTION_SIZE
  454: #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)			\
  455:   do {									\
  456:     if (!flag_inhibit_size_directive)					\
  457:       {									\
  458:         char label[256];						\
  459: 	static int labelno;						\
  460: 	labelno++;							\
  461: 	ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno);		\
  462: 	ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno);		\
  463: 	fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);				\
  464: 	assemble_name (FILE, (FNAME));					\
  465:         fprintf (FILE, ",");						\
  466: 	assemble_name (FILE, label);					\
  467:         fprintf (FILE, "-");						\
  468: 	assemble_name (FILE, (FNAME));					\
  469: 	putc ('\n', FILE);						\
  470:       }									\
  471:   } while (0)
  472: 
  473: 
  474: /* The routine used to output NUL terminated strings.  We use a special
  475:    version of this for most svr4 targets because doing so makes the
  476:    generated assembly code more compact (and thus faster to assemble)
  477:    as well as more readable, especially for targets like the i386
  478:    (where the only alternative is to output character sequences as
  479:    comma separated lists of numbers).   */
  480: 
  481: #undef  ASM_OUTPUT_LIMITED_STRING
  482: #define ASM_OUTPUT_LIMITED_STRING(FILE, STR)				\
  483:   do {									\
  484:       register unsigned char *_limited_str = (unsigned char *) (STR);	\
  485:       register unsigned ch;						\
  486:       fprintf ((FILE), "\t%s\t\"", STRING_ASM_OP);			\
  487:       for (; (ch = *_limited_str); _limited_str++)			\
  488:         {								\
  489: 	  register int escape;						\
  490: 	  switch (escape = ESCAPES[ch])					\
  491: 	    {								\
  492: 	    case 0:							\
  493: 	      putc (ch, (FILE));					\
  494: 	      break;							\
  495: 	    case 1:							\
  496: 	      fprintf ((FILE), "\\%03o", ch);				\
  497: 	      break;							\
  498: 	    default:							\
  499: 	      putc ('\\', (FILE));					\
  500: 	      putc (escape, (FILE));					\
  501: 	      break;							\
  502: 	    }								\
  503:         }								\
  504:       fprintf ((FILE), "\"\n");						\
  505:   } while (0)
  506: 
  507: /* Switch into a generic section.
  508:  
  509:    We make the section read-only and executable for a function decl,
  510:    read-only for a const data decl, and writable for a non-const data decl.
  511:  
  512:    If the section has already been defined, we must not
  513:    emit the attributes here. The SVR4 assembler does not
  514:    recognize section redefinitions.
  515:    If DECL is NULL, no attributes are emitted.  */
  516: 
  517: #undef  ASM_OUTPUT_SECTION_NAME
  518: #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME, RELOC)		\
  519:   do {									\
  520:     static struct section_info						\
  521:       {									\
  522: 	struct section_info *next;				        \
  523: 	char *name;						        \
  524: 	enum sect_enum {SECT_RW, SECT_RO, SECT_EXEC} type;		\
  525:       } *sections;							\
  526:     struct section_info *s;						\
  527:     char *mode;								\
  528:     enum sect_enum type;						\
  529: 									\
  530:     for (s = sections; s; s = s->next)					\
  531:       if (!strcmp (NAME, s->name))					\
  532: 	break;								\
  533: 									\
  534:     if (DECL && TREE_CODE (DECL) == FUNCTION_DECL)			\
  535:       type = SECT_EXEC, mode = "ax";					\
  536:     else if (DECL && DECL_READONLY_SECTION (DECL, RELOC))		\
  537:       type = SECT_RO, mode = "a";					\
  538:     else								\
  539:       type = SECT_RW, mode = "aw";					\
  540: 									\
  541:     if (s == 0)								\
  542:       {									\
  543: 	s = (struct section_info *) xmalloc (sizeof (struct section_info));  \
  544: 	s->name = xmalloc ((strlen (NAME) + 1) * sizeof (*NAME));	\
  545: 	strcpy (s->name, NAME);						\
  546: 	s->type = type;							\
  547: 	s->next = sections;						\
  548: 	sections = s;							\
  549: 	fprintf (FILE, ".section\t%s,\"%s\",@progbits\n", NAME, mode);	\
  550:       }									\
  551:     else								\
  552:       {									\
  553: 	if (DECL && s->type != type)					\
  554: 	  error_with_decl (DECL, "%s causes a section type conflict");	\
  555: 									\
  556: 	fprintf (FILE, ".section\t%s\n", NAME);				\
  557:       }									\
  558:   } while (0)
  559: 
  560: #undef  MAKE_DECL_ONE_ONLY
  561: #define MAKE_DECL_ONE_ONLY(DECL)	(DECL_WEAK (DECL) = 1)
  562: #undef  UNIQUE_SECTION_P
  563: #define UNIQUE_SECTION_P(DECL)		(DECL_ONE_ONLY (DECL))
  564: #undef  UNIQUE_SECTION
  565: #define UNIQUE_SECTION(DECL,RELOC)					\
  566:   do {									\
  567:     int len;								\
  568:     char *name, *string, *prefix;					\
  569: 									\
  570:     name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (DECL));		\
  571: 									\
  572:     if (! DECL_ONE_ONLY (DECL))						\
  573:       {									\
  574: 	prefix = ".";                                             	\
  575: 	if (TREE_CODE (DECL) == FUNCTION_DECL)				\
  576: 	  prefix = ".text.";						\
  577: 	else if (DECL_READONLY_SECTION (DECL, RELOC))			\
  578: 	  prefix = ".rodata.";						\
  579: 	else								\
  580: 	  prefix = ".data.";						\
  581:       }									\
  582:     else if (TREE_CODE (DECL) == FUNCTION_DECL)				\
  583:       prefix = ".gnu.linkonce.t.";					\
  584:     else if (DECL_READONLY_SECTION (DECL, RELOC))			\
  585:       prefix = ".gnu.linkonce.r.";					\
  586:     else								\
  587:       prefix = ".gnu.linkonce.d.";					\
  588: 									\
  589:     len = strlen (name) + strlen (prefix);				\
  590:     string = alloca (len + 1);						\
  591:     sprintf (string, "%s%s", prefix, name);				\
  592: 									\
  593:     DECL_SECTION_NAME (DECL) = build_string (len, string);		\
  594:   } while (0)
  595: 
  596: /* A C statement or statements to switch to the appropriate
  597:    section for output of DECL.  DECL is either a `VAR_DECL' node
  598:    or a constant of some sort.  RELOC indicates whether forming
  599:    the initial value of DECL requires link-time relocations.  */
  600: 
  601: #undef  SELECT_SECTION
  602: #define SELECT_SECTION(DECL,RELOC)					\
  603:   {									\
  604:     if (flag_pic && RELOC)						\
  605:       data_section ();							\
  606:     else if (TREE_CODE (DECL) == STRING_CST)				\
  607:       {									\
  608: 	if (! flag_writable_strings)					\
  609: 	  const_section ();						\
  610: 	else								\
  611: 	  data_section ();						\
  612:       }									\
  613:     else if (TREE_CODE (DECL) == VAR_DECL)				\
  614:       {									\
  615: 	if (! DECL_READONLY_SECTION (DECL, RELOC))			\
  616: 	  data_section ();						\
  617: 	else								\
  618: 	  const_section ();						\
  619:       }									\
  620:     else								\
  621:       const_section ();							\
  622:   }
  623: 
  624: /* A C statement (sans semicolon) to output an element in the table of
  625:    global constructors.  */
  626: #undef  ASM_OUTPUT_CONSTRUCTOR
  627: #define ASM_OUTPUT_CONSTRUCTOR(FILE, NAME)				\
  628:   do {									\
  629:     if (TARGET_ELF)							\
  630:       {									\
  631: 	ctors_section ();						\
  632: 	fprintf ((FILE), "%s ", INT_ASM_OP);				\
  633: 	assemble_name ((FILE), (NAME));					\
  634: 	fprintf ((FILE), "\n");						\
  635:       }									\
  636:     else								\
  637:       {									\
  638: 	fprintf (asm_out_file, "%s \"%s__CTOR_LIST__\",22,0,0,",	\
  639: 		 ASM_STABS_OP, (TARGET_UNDERSCORES) ? "_" : "");	\
  640: 	assemble_name (asm_out_file, name);				\
  641: 	fputc ('\n', asm_out_file);					\
  642:       }									\
  643:   } while (0)
  644: 
  645: /* A C statement (sans semicolon) to output an element in the table of
  646:    global destructors.  */
  647: #undef  ASM_OUTPUT_DESTRUCTOR
  648: #define ASM_OUTPUT_DESTRUCTOR(FILE, NAME)				\
  649:   do {									\
  650:     if (TARGET_ELF)							\
  651:       {									\
  652: 	dtors_section ();						\
  653: 	fprintf ((FILE), "%s ", INT_ASM_OP);				\
  654: 	assemble_name ((FILE), (NAME));					\
  655: 	fprintf ((FILE), "\n");						\
  656:       }									\
  657:     else								\
  658:       {									\
  659: 	fprintf (asm_out_file, "%s \"%s__DTOR_LIST__\",22,0,0,",	\
  660: 		 ASM_STABS_OP, (TARGET_UNDERSCORES) ? "_" : "");	\
  661: 	assemble_name (asm_out_file, name);				\
  662: 	fputc ('\n', asm_out_file);					\
  663:       }									\
  664:   } while (0)
  665: 
  666: /* Define macro used to output shift-double opcodes when the shift
  667:    count is in %cl.  Some assemblers require %cl as an argument;
  668:    some don't.
  669: 
  670:    *OLD* GAS requires the %cl argument, so override i386/unix.h. */
  671:       
  672: #undef  AS3_SHIFT_DOUBLE
  673: #define AS3_SHIFT_DOUBLE(a,b,c,d)	AS3 (a,b,c,d)
  674: 
  675: 
  676: /************************[  Debugger stuff  ]*********************************/
  677: 
  678: /* Copy this from the svr4 specifications... */
  679: /* Define the register numbers to be used in Dwarf debugging information.
  680:    The SVR4 reference port C compiler uses the following register numbers
  681:    in its Dwarf output code:
  682: 	0 for %eax (gnu regno = 0)
  683: 	1 for %ecx (gnu regno = 2)
  684: 	2 for %edx (gnu regno = 1)
  685: 	3 for %ebx (gnu regno = 3)
  686: 	4 for %esp (gnu regno = 7)
  687: 	5 for %ebp (gnu regno = 6)
  688: 	6 for %esi (gnu regno = 4)
  689: 	7 for %edi (gnu regno = 5)
  690:    The following three DWARF register numbers are never generated by
  691:    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
  692:    believes these numbers have these meanings.
  693: 	8  for %eip    (no gnu equivalent)
  694: 	9  for %eflags (no gnu equivalent)
  695: 	10 for %trapno (no gnu equivalent)
  696:    It is not at all clear how we should number the FP stack registers
  697:    for the x86 architecture.  If the version of SDB on x86/svr4 were
  698:    a bit less brain dead with respect to floating-point then we would
  699:    have a precedent to follow with respect to DWARF register numbers
  700:    for x86 FP registers, but the SDB on x86/svr4 is so completely
  701:    broken with respect to FP registers that it is hardly worth thinking
  702:    of it as something to strive for compatibility with.
  703:    The version of x86/svr4 SDB I have at the moment does (partially)
  704:    seem to believe that DWARF register number 11 is associated with
  705:    the x86 register %st(0), but that's about all.  Higher DWARF
  706:    register numbers don't seem to be associated with anything in
  707:    particular, and even for DWARF regno 11, SDB only seems to under-
  708:    stand that it should say that a variable lives in %st(0) (when
  709:    asked via an `=' command) if we said it was in DWARF regno 11,
  710:    but SDB still prints garbage when asked for the value of the
  711:    variable in question (via a `/' command).
  712:    (Also note that the labels SDB prints for various FP stack regs
  713:    when doing an `x' command are all wrong.)
  714:    Note that these problems generally don't affect the native SVR4
  715:    C compiler because it doesn't allow the use of -O with -g and
  716:    because when it is *not* optimizing, it allocates a memory
  717:    location for each floating-point variable, and the memory
  718:    location is what gets described in the DWARF AT_location
  719:    attribute for the variable in question.
  720:    Regardless of the severe mental illness of the x86/svr4 SDB, we
  721:    do something sensible here and we use the following DWARF
  722:    register numbers.  Note that these are all stack-top-relative
  723:    numbers.
  724: 	11 for %st(0) (gnu regno = 8)
  725: 	12 for %st(1) (gnu regno = 9)
  726: 	13 for %st(2) (gnu regno = 10)
  727: 	14 for %st(3) (gnu regno = 11)
  728: 	15 for %st(4) (gnu regno = 12)
  729: 	16 for %st(5) (gnu regno = 13)
  730: 	17 for %st(6) (gnu regno = 14)
  731: 	18 for %st(7) (gnu regno = 15)
  732: */
  733: #undef  DWARF_DBX_REGISTER_NUMBER
  734: #define DWARF_DBX_REGISTER_NUMBER(n) \
  735: ((n) == 0 ? 0 \
  736:  : (n) == 1 ? 2 \
  737:  : (n) == 2 ? 1 \
  738:  : (n) == 3 ? 3 \
  739:  : (n) == 4 ? 6 \
  740:  : (n) == 5 ? 7 \
  741:  : (n) == 6 ? 5 \
  742:  : (n) == 7 ? 4 \
  743:  : ((n) >= FIRST_STACK_REG && (n) <= LAST_STACK_REG) ? (n)+3 \
  744:  : (-1))
  745: 
  746: /* Now what stabs expects in the register.  */
  747: #undef  STABS_DBX_REGISTER_NUMBER
  748: #define STABS_DBX_REGISTER_NUMBER(n) \
  749: ((n) == 0 ? 0 : \
  750:  (n) == 1 ? 2 : \
  751:  (n) == 2 ? 1 : \
  752:  (n) == 3 ? 3 : \
  753:  (n) == 4 ? 6 : \
  754:  (n) == 5 ? 7 : \
  755:  (n) == 6 ? 4 : \
  756:  (n) == 7 ? 5 : \
  757:  (n) + 4)
  758: 
  759: #undef  DBX_REGISTER_NUMBER
  760: #define DBX_REGISTER_NUMBER(n)	((write_symbols == DWARF_DEBUG)		\
  761: 				? DWARF_DBX_REGISTER_NUMBER(n)		\
  762: 				: STABS_DBX_REGISTER_NUMBER(n))
  763: 
  764: /* tag end of file in elf mode */
  765: #undef  DBX_OUTPUT_MAIN_SOURCE_FILE_END
  766: #define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME)			\
  767:   do {									\
  768:     if (TARGET_ELF) {							\
  769:       fprintf ((FILE), "\t.text\n\t.stabs \"\",%d,0,0,.Letext\n.Letext:\n", \
  770: 		N_SO);							\
  771:     }									\
  772:   } while (0)
  773: 
  774: /* stabs-in-elf has offsets relative to function beginning */
  775: #undef  DBX_OUTPUT_LBRAC
  776: #define DBX_OUTPUT_LBRAC(FILE, NAME)					\
  777:   do {									\
  778:     fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);		\
  779:     assemble_name (asmfile, buf);					\
  780:     if (TARGET_ELF)							\
  781:       {									\
  782:         fputc ('-', asmfile);						\
  783:         assemble_name (asmfile,						\
  784: 	      	 XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));	\
  785:       }									\
  786:     fprintf (asmfile, "\n");						\
  787:   } while (0)
  788: 
  789: #undef  DBX_OUTPUT_RBRAC
  790: #define DBX_OUTPUT_RBRAC(FILE, NAME)					\
  791:   do {									\
  792:     fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);		\
  793:     assemble_name (asmfile, buf);					\
  794:     if (TARGET_ELF)							\
  795:       {									\
  796:         fputc ('-', asmfile);						\
  797:         assemble_name (asmfile,						\
  798: 		 XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));	\
  799:       }									\
  800:     fprintf (asmfile, "\n");						\
  801:   } while (0)