OSDN Git Service

Merge basic-improvements-branch to trunk
[pf3gnuchains/gcc-fork.git] / gcc / config / pdp11 / pdp11.h
index 7912bea..f9eb3f0 100644 (file)
@@ -1,12 +1,13 @@
 /* Definitions of target machine for GNU compiler, for the pdp-11
-   Copyright (C) 1994, 1995, 1996, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
+   Free Software Foundation, Inc.
    Contributed by Michael K. Gschwind (mike@vlsivie.tuwien.ac.at).
 
 This file is part of GNU CC.
 
 GNU CC is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
 any later version.
 
 GNU CC is distributed in the hope that it will be useful,
@@ -19,12 +20,7 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
-
-/* declarations */
-char *output_jump();
-char *output_move_double();
-char *output_move_quad();
-char *output_block_move();
+#define CONSTANT_POOL_BEFORE_FUNCTION  0
 
 /* check whether load_fpu_reg or not */
 #define LOAD_FPU_REG_P(x) ((x)>=8 && (x)<=11)
@@ -50,53 +46,57 @@ char *output_block_move();
 extern int target_flags;
 
 /* Macro to define tables used to set the flags.
-   This is a list in braces of pairs in braces,
-   each pair being { "NAME", VALUE }
-   where VALUE is the bits to set or minus the bits to clear.
+   This is a list in braces of triplets in braces,
+   each triplet being { "NAME", VALUE, DOC }
+   where VALUE is the bits to set or minus the bits to clear and DOC
+   is the documentation for --help (NULL if intentionally undocumented).
    An empty string NAME is used to identify the default VALUE.  */
 
 #define TARGET_SWITCHES  \
-{   { "fpu", 1},               \
-    { "soft-float", -1},               \
-/* return float result in ac0 */\
-    { "ac0", 2},               \
-    { "no-ac0", -2},           \
-/* is 11/40 */                 \
-    { "40", 4},                        \
-    { "no-40", -4},            \
-/* is 11/45 */                 \
-    { "45", 8},                        \
-    { "no-45", -8},            \
-/* is 11/10 */                 \
-    { "10", -12},              \
-/* use movstrhi for bcopy */   \
-    { "bcopy", 16},            \
-    { "bcopy-builtin", -16},   \
-/* use 32 bit for int */       \
-    { "int32", 32},            \
-    { "no-int16", 32},         \
-    { "int16", -32},           \
-    { "no-int32", -32},                \
-/* use 32 bit for float */     \
-    { "float32", 64},          \
-    { "no-float64", 64},       \
-    { "float64", -64},         \
-    { "no-float32", -64},      \
+{   { "fpu", 1, N_("Use hardware floating point") },                   \
+    { "soft-float", -1, N_("Do not use hardware floating point") },    \
+/* return float result in ac0 */                                       \
+    { "ac0", 2, N_("Return floating point results in ac0") },          \
+    { "no-ac0", -2, N_("Return floating point results in memory") },   \
+/* is 11/40 */                                                         \
+    { "40", 4, N_("Generate code for an 11/40") },                     \
+    { "no-40", -4, "" },                                               \
+/* is 11/45 */                                                         \
+    { "45", 8, N_("Generate code for an 11/45") },                     \
+    { "no-45", -8, "" },                                               \
+/* is 11/10 */                                                         \
+    { "10", -12, N_("Generate code for an 11/10") },                   \
+/* use movstrhi for bcopy */                                           \
+    { "bcopy", 16, NULL },                                             \
+    { "bcopy-builtin", -16, NULL },                                    \
+/* use 32 bit for int */                                               \
+    { "int32", 32, N_("Use 32 bit int") },                             \
+    { "no-int16", 32, N_("Use 32 bit int") },                          \
+    { "int16", -32, N_("Use 16 bit int") },                            \
+    { "no-int32", -32, N_("Use 16 bit int") },                         \
+/* use 32 bit for float */                                             \
+    { "float32", 64, N_("Use 32 bit float") },                         \
+    { "no-float64", 64, N_("Use 32 bit float") },                      \
+    { "float64", -64, N_("Use 64 bit float") },                                \
+    { "no-float32", -64, N_("Use 64 bit float") },                     \
 /* allow abshi pattern? - can trigger "optimizations" which make code SLOW! */\
-    { "abshi", 128},           \
-    { "no-abshi", -128},       \
+    { "abshi", 128, NULL },                                            \
+    { "no-abshi", -128, NULL },                                                \
 /* is branching expensive - on a PDP, it's actually really cheap */ \
 /* this is just to play around and check what code gcc generates */ \
-    { "branch-expensive", 256}, \
-    { "branch-cheap", -256},   \
-/* split instruction and data memory? */ \
-    { "split", 1024 },         \
-    { "no-split", -1024 },     \
+    { "branch-expensive", 256, NULL },                                         \
+    { "branch-cheap", -256, NULL },                                    \
+/* split instruction and data memory? */                               \
+    { "split", 1024, N_("Target has split I&D") },                     \
+    { "no-split", -1024, N_("Target does not have split I&D") },       \
+/* UNIX assembler syntax?  */                                          \
+    { "unix-asm", 2048, N_("Use UNIX assembler syntax") },             \
+    { "dec-asm", -2048, N_("Use DEC assembler syntax") },              \
 /* default */                  \
-    { "", TARGET_DEFAULT}      \
+    { "", TARGET_DEFAULT, NULL}        \
 }
 
-#define TARGET_DEFAULT (1 | 8 | 128)
+#define TARGET_DEFAULT (1 | 8 | 128 | TARGET_UNIX_ASM_DEFAULT)
 
 #define TARGET_FPU             (target_flags & 1)
 #define TARGET_SOFT_FLOAT      (!TARGET_FPU)
@@ -123,10 +123,15 @@ extern int target_flags;
 
 #define TARGET_SPLIT           (target_flags & 1024)
 #define TARGET_NOSPLIT         (! TARGET_SPLIT)
+
+#define TARGET_UNIX_ASM                (target_flags & 2048)
+#define TARGET_UNIX_ASM_DEFAULT        0
+
+#define ASSEMBLER_DIALECT      (TARGET_UNIX_ASM ? 1 : 0)
+
 \f
 
 /* TYPE SIZES */
-#define CHAR_TYPE_SIZE         8
 #define SHORT_TYPE_SIZE                16
 #define INT_TYPE_SIZE          (TARGET_INT16 ? 16 : 32)
 #define LONG_TYPE_SIZE         32
@@ -143,11 +148,6 @@ extern int target_flags;
 
 /* machine types from ansi */
 #define SIZE_TYPE "unsigned int"       /* definition of size_t */
-
-/* is used in cexp.y - we don't have target_flags there, 
-   so just give default definition 
-
-   hope it does not come back to haunt us! */
 #define WCHAR_TYPE "int"               /* or long int???? */
 #define WCHAR_TYPE_SIZE 16
 
@@ -165,16 +165,6 @@ extern int target_flags;
 /* Define this if most significant word of a multiword number is numbered.  */
 #define WORDS_BIG_ENDIAN 1
 
-/* number of bits in an addressable storage unit */
-#define BITS_PER_UNIT 8
-
-/* Width in bits of a "word", which is the contents of a machine register.
-   Note that this is not necessarily the width of data type `int';
-   if using 16-bit ints on a 68000, this would still be 32.
-   But on a machine with 16-bit registers, this would be 16.  */
-/*  This is a machine with 16-bit registers */
-#define BITS_PER_WORD 16
-
 /* Width of a word, in units (bytes). 
 
    UNITS OR BYTES - seems like units */
@@ -184,16 +174,15 @@ extern int target_flags;
    DImode or Dfmode ...*/
 #define MAX_FIXED_MODE_SIZE 64 
 
-/* Width in bits of a pointer.
-   See also the macro `Pmode' defined below.  */
-#define POINTER_SIZE 16
-
 /* Allocation boundary (in *bits*) for storing pointers in memory.  */
 #define POINTER_BOUNDARY 16
 
 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
 #define PARM_BOUNDARY 16
 
+/* Boundary (in *bits*) on which stack pointer should be aligned.  */
+#define STACK_BOUNDARY 16
+
 /* Allocation boundary (in *bits*) for the code of a function.  */
 #define FUNCTION_BOUNDARY 16
 
@@ -253,7 +242,8 @@ extern int target_flags;
 /* Make sure everything's fine if we *don't* have an FPU.
    This assumes that putting a register in fixed_regs will keep the
    compiler's mitts completely off it.  We don't bother to zero it out
-   of register classes.  
+   of register classes.  Also fix incompatible register naming with
+   the UNIX assembler.
 */
 #define CONDITIONAL_REGISTER_USAGE \
 {                                              \
@@ -269,6 +259,16 @@ extern int target_flags;
                                                \
   if (TARGET_AC0)                              \
       call_used_regs[8] = 1;                   \
+  if (TARGET_UNIX_ASM)                         \
+    {                                          \
+      /* Change names of FPU registers for the UNIX assembler.  */ \
+      reg_names[8] = "fr0";                    \
+      reg_names[9] = "fr1";                    \
+      reg_names[10] = "fr2";                   \
+      reg_names[11] = "fr3";                   \
+      reg_names[12] = "fr4";                   \
+      reg_names[13] = "fr5";                   \
+    }                                          \
 }
 
 /* Return number of consecutive hard regs needed starting at reg REGNO
@@ -289,9 +289,9 @@ extern int target_flags;
    FPU can only hold DF - simplifies life!
 */
 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
-((REGNO < 8)?                                          \
+(((REGNO) < 8)?                                                \
   ((GET_MODE_BITSIZE(MODE) <= 16)                      \
-   || (GET_MODE_BITSIZE(MODE) == 32 && !(REGNO & 1)))  \
+   || (GET_MODE_BITSIZE(MODE) == 32 && !((REGNO) & 1)))        \
   :(MODE) == DFmode)
     
 
@@ -387,7 +387,7 @@ enum reg_class { NO_REGS, MUL_REGS, GENERAL_REGS, LOAD_FPU_REGS, NO_LOAD_FPU_REG
    This is an initializer for a vector of HARD_REG_SET
    of length N_REG_CLASSES.  */
 
-#define REG_CLASS_CONTENTS {0, 0x00aa, 0x00ff, 0x0f00, 0x3000, 0x3f00, 0x3fff}
+#define REG_CLASS_CONTENTS {{0}, {0x00aa}, {0x00ff}, {0x0f00}, {0x3000}, {0x3f00}, {0x3fff}}
 
 /* The same information, inverted:
    Return the class number of the smallest class containing
@@ -395,7 +395,7 @@ enum reg_class { NO_REGS, MUL_REGS, GENERAL_REGS, LOAD_FPU_REGS, NO_LOAD_FPU_REG
    or could index an array.  */
 
 #define REGNO_REG_CLASS(REGNO)                 \
-((REGNO)>=8?((REGNO)<=11?LOAD_FPU_REGS:NO_LOAD_FPU_REGS):((REGNO&1)?MUL_REGS:GENERAL_REGS))
+((REGNO)>=8?((REGNO)<=11?LOAD_FPU_REGS:NO_LOAD_FPU_REGS):(((REGNO)&1)?MUL_REGS:GENERAL_REGS))
 
 
 /* The class value for index registers, and the one for base regs.  */
@@ -509,7 +509,7 @@ loading is easier into LOAD_FPU_REGS than FPU_REGS! */
 extern int current_first_parm_offset;
 
 /* Offset of first parameter from the argument pointer register value.  
-   For the pdp11, this is non-zero to account for the return address.
+   For the pdp11, this is nonzero to account for the return address.
        1 - return address
        2 - frame pointer (always saved, even when not used!!!!)
                -- chnage some day !!!:q!
@@ -536,18 +536,18 @@ extern int current_first_parm_offset;
 not without FPU!!!! ) */
 
 #define FUNCTION_VALUE(VALTYPE, FUNC)  \
-  gen_rtx (REG, TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE)))
+  gen_rtx_REG (TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE)))
 
 /* and the called function leaves it in the first register.
    Difference only on machines with register windows.  */
 
 #define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC)  \
-  gen_rtx (REG, TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE)))
+  gen_rtx_REG (TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE)))
 
 /* Define how to find the value returned by a library function
    assuming the value has mode MODE.  */
 
-#define LIBCALL_VALUE(MODE)  gen_rtx (REG, MODE, BASE_RETURN_VALUE_REG(MODE))
+#define LIBCALL_VALUE(MODE)  gen_rtx_REG (MODE, BASE_RETURN_VALUE_REG(MODE))
 
 /* 1 if N is a possible register number for a function value
    as seen by the caller.
@@ -635,10 +635,6 @@ maybe ac0 ? - as option someday! */
 
 #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) 0
 
-/* This macro generates the assembly code for function entry. */
-#define FUNCTION_PROLOGUE(FILE, SIZE) \
-    output_function_prologue(FILE, SIZE);
-
 /* Output assembler code to FILE to increment profiler label # LABELNO
    for profiling a function entry.  */
 
@@ -651,19 +647,9 @@ maybe ac0 ? - as option someday! */
    No definition is equivalent to always zero.  */
 
 extern int may_call_alloca;
-extern int current_function_pretend_args_size;
 
 #define EXIT_IGNORE_STACK      1
 
-/* This macro generates the assembly code for function exit,
-   on machines that need it.  If FUNCTION_EPILOGUE is not defined
-   then individual return instructions are generated for each
-   return statement.  Args are same as for FUNCTION_PROLOGUE.
-*/
-
-#define FUNCTION_EPILOGUE(FILE, SIZE) \
-    output_function_epilogue(FILE, SIZE);
-  
 #define INITIAL_FRAME_POINTER_OFFSET(DEPTH_VAR)        \
 {                                                              \
   int offset, regno;                                           \
@@ -682,10 +668,8 @@ extern int current_function_pretend_args_size;
 /* Addressing modes, and classification of registers for them.  */
 
 #define HAVE_POST_INCREMENT 1
-/* #define HAVE_POST_DECREMENT 0 */
 
 #define HAVE_PRE_DECREMENT 1
-/* #define HAVE_PRE_INCREMENT 0 */
 
 /* Macros to check register numbers against specific register classes.  */
 
@@ -717,7 +701,7 @@ extern int current_function_pretend_args_size;
 /* Nonzero if the constant value X is a legitimate general operand.
    It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
 
-#define LEGITIMATE_CONSTANT_P(X) (1)
+#define LEGITIMATE_CONSTANT_P(X) (TARGET_FPU? 1: !(GET_CODE(X) == CONST_DOUBLE))
 
 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
    and check its validity for a certain class.
@@ -788,6 +772,29 @@ extern int current_function_pretend_args_size;
        && GET_CODE (XEXP (operand, 0)) == REG                          \
        && REG_OK_FOR_BASE_P (XEXP (operand, 0)))                       \
       goto ADDR;                                                       \
+                                                                       \
+    /* accept -(SP) -- which uses PRE_MODIFY for byte mode */          \
+    if (GET_CODE (operand) == PRE_MODIFY                               \
+       && GET_CODE (XEXP (operand, 0)) == REG                          \
+       && REGNO (XEXP (operand, 0)) == 6                               \
+       && GET_CODE ((xfoob = XEXP (operand, 1))) == PLUS               \
+       && GET_CODE (XEXP (xfoob, 0)) == REG                            \
+       && REGNO (XEXP (xfoob, 0)) == 6                                 \
+       && CONSTANT_P (XEXP (xfoob, 1))                                 \
+       && INTVAL (XEXP (xfoob,1)) == -2)                               \
+      goto ADDR;                                                       \
+                                                                       \
+    /* accept (SP)+ -- which uses POST_MODIFY for byte mode */         \
+    if (GET_CODE (operand) == POST_MODIFY                              \
+       && GET_CODE (XEXP (operand, 0)) == REG                          \
+       && REGNO (XEXP (operand, 0)) == 6                               \
+       && GET_CODE ((xfoob = XEXP (operand, 1))) == PLUS               \
+       && GET_CODE (XEXP (xfoob, 0)) == REG                            \
+       && REGNO (XEXP (xfoob, 0)) == 6                                 \
+       && CONSTANT_P (XEXP (xfoob, 1))                                 \
+       && INTVAL (XEXP (xfoob,1)) == 2)                                \
+      goto ADDR;                                                       \
+                                                                       \
                                                                        \
     /* handle another level of indirection ! */                                \
     if (GET_CODE(operand) != MEM)                                      \
@@ -879,12 +886,6 @@ extern int current_function_pretend_args_size;
    Do not define this if the table should contain absolute addresses. */
 /* #define CASE_VECTOR_PC_RELATIVE 1 */
 
-/* Specify the tree operation to be used to convert reals to integers.  */
-#define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
-
-/* This is the kind of divide that is easiest to do in the general case.  */
-#define EASY_DIV_EXPR TRUNC_DIV_EXPR
-
 /* Define this as 1 if `char' should by default be signed; else as 0.  */
 #define DEFAULT_SIGNED_CHAR 1
 
@@ -894,9 +895,6 @@ extern int current_function_pretend_args_size;
 
 #define MOVE_MAX 2
 
-/* Zero extension is faster if the target is known to be zero */
-/* #define SLOW_ZERO_EXTEND */
-
 /* Nonzero if access to memory by byte is slow and undesirable. -
 */
 #define SLOW_BYTE_ACCESS 0
@@ -908,15 +906,6 @@ extern int current_function_pretend_args_size;
    is done just by pretending it is already truncated.  */
 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
 
-
-/* Add any extra modes needed to represent the condition code.
-
-   CCFPmode is used for FPU, but should we use a separate reg? */
-#define EXTRA_CC_MODES CCFPmode
-
-/* the name for the mode above */
-#define EXTRA_CC_NAMES "CCFPmode"
-
 /* Give a comparison code (EQ, NE etc) and the first operand of a COMPARE,
    return the mode to be used for the comparison.  For floating-point, CCFPmode
    should be used. */
@@ -969,7 +958,8 @@ extern int current_function_pretend_args_size;
     return 4;
 \f
 /* cost of moving one register class to another */
-#define REGISTER_MOVE_COST(CLASS1, CLASS2) register_move_cost(CLASS1, CLASS2)
+#define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2) \
+  register_move_cost (CLASS1, CLASS2)
 
 /* Tell emit-rtl.c how to initialize special values on a per-function base.  */
 extern int optimize;
@@ -1013,8 +1003,11 @@ extern struct rtx_def *cc0_reg_rtx;
     { /* all bets are off */ CC_STATUS_INIT; }                 \
   if (cc_status.value1 && GET_CODE (cc_status.value1) == REG   \
       && cc_status.value2                                      \
-      && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2)) \
-    printf ("here!\n", cc_status.value2 = 0);                  \
+      && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2)) \
+    {                                                          \
+      printf ("here!\n");                                      \
+      cc_status.value2 = 0;                                    \
+    }                                                          \
 }
 \f
 /* Control the assembler format that we output.  */
@@ -1029,7 +1022,7 @@ fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n")        \
 /* do we need reg def's R0 = %0 etc ??? */                     \
 )
 #else
-#define ASM_FILE_START(FILE)   (0)
+#define ASM_FILE_START(FILE)
 #endif
 
 
@@ -1055,35 +1048,16 @@ fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n")      \
    This sequence is indexed by compiler's hard-register-number (see above).  */
 
 #define REGISTER_NAMES \
-{"r0", "r1", "r2", "r3", "r4", "fp", "sp", "pc",     \
+{"r0", "r1", "r2", "r3", "r4", "r5", "sp", "pc",     \
  "ac0", "ac1", "ac2", "ac3", "ac4", "ac5" }
 
-/* How to renumber registers for dbx and gdb.  */
-
-#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
-
-/* This is how to output the definition of a user-level label named NAME,
-   such as the label on a static function or variable NAME.  */
-
-#define ASM_OUTPUT_LABEL(FILE,NAME)    \
-  do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0)
-
-/* This is how to output a command to make the user-level label named NAME
-   defined for reference from other files.  */
-
-#define ASM_GLOBALIZE_LABEL(FILE,NAME) \
-  do { fputs ("\t.globl ", FILE); assemble_name (FILE, NAME); fputs("\n", FILE); } while (0)
+/* Globalizing directive for a label.  */
+#define GLOBAL_ASM_OP "\t.globl "
 
 /* The prefix to add to user-visible assembler symbols. */
 
 #define USER_LABEL_PREFIX "_"
 
-/* This is how to output an internal numbered label where
-   PREFIX is the class of label and NUM is the number within the class.  */
-
-#define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)     \
-  fprintf (FILE, "%s_%d:\n", PREFIX, NUM)
-
 /* This is how to store into the string LABEL
    the symbol_ref name of an internal numbered label where
    PREFIX is the class of label and NUM is the number within the class.
@@ -1092,54 +1066,13 @@ fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n")      \
 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)  \
   sprintf (LABEL, "*%s_%d", PREFIX, NUM)
 
-/* This is how to output an assembler line defining a `double' constant.  */
-
-#define ASM_OUTPUT_DOUBLE(FILE,VALUE)  \
-  fprintf (FILE, "\tdouble %.20e\n", (VALUE))
-
-/* This is how to output an assembler line defining a `float' constant.  */
-
-#define ASM_OUTPUT_FLOAT(FILE,VALUE)  \
-  fprintf (FILE, "\tfloat %.12e\n", (VALUE))
-
-/* This is how to output an assembler line defining an `int' constant.  */
-
-#define ASM_OUTPUT_INT(FILE,VALUE)  \
-( fprintf (FILE, "\t.word "),                  \
-  output_addr_const (FILE, (VALUE)),           \
-  fprintf (FILE, "\n"))
-
-/* Likewise for `short' and `char' constants.  */
-
-#define ASM_OUTPUT_SHORT(FILE,VALUE)  \
-( fprintf (FILE, "\t.word "),                  \
-  output_addr_const (FILE, (VALUE)),           \
-  fprintf (FILE, " /*short*/\n"))
-
-#define ASM_OUTPUT_CHAR(FILE,VALUE)  \
-( fprintf (FILE, "\t.byte "),                  \
-  output_addr_const (FILE, (VALUE)),           \
-  fprintf (FILE, " /* char */\n"))
-
-/* This is how to output an assembler line for a numeric constant byte.-
-
-   do we really NEED it ? let's output it with a comment and grep the 
-   assembly source ;-)
-*/
-
-#define ASM_OUTPUT_BYTE(FILE,VALUE)  \
-  fprintf (FILE, "\t.byte 0x%x\n", (VALUE))
-
 #define ASM_OUTPUT_ASCII(FILE, P, SIZE)  \
   output_ascii (FILE, P, SIZE)
 
-#define ASM_OUTPUT_ADDR_VEC_PROLOGUE(FILE, MODE, LEN)  \
-  fprintf (FILE, "\t/* HELP! */\n");
-
 /* This is how to output an element of a case-vector that is absolute.  */
 
 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
-  fprintf (FILE, "\t.word L_%d\n", VALUE)
+  fprintf (FILE, "\t%sL_%d\n", TARGET_UNIX_ASM ? "" : ".word ", VALUE)
 
 /* This is how to output an element of a case-vector that is relative.
    Don't define this if it is not supported. */
@@ -1154,11 +1087,19 @@ fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n")      \
 */
 
 #define ASM_OUTPUT_ALIGN(FILE,LOG)     \
-  if ((LOG) != 0)                      \
-    fprintf (FILE, "\t.align %d\n", 1<<(LOG))
+  switch (LOG)                         \
+    {                                  \
+      case 0:                          \
+       break;                          \
+      case 1:                          \
+       fprintf (FILE, "\t.even\n");    \
+       break;                          \
+      default:                         \
+       abort ();                       \
+    }
 
 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
-  fprintf (FILE, "\t.=.+ %d\n", (SIZE))
+  fprintf (FILE, "\t.=.+ %#ho\n", (unsigned short)(SIZE))
 
 /* This says how to output an assembler line
    to define a global common symbol.  */
@@ -1168,7 +1109,7 @@ fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n")        \
   assemble_name ((FILE), (NAME)),              \
   fprintf ((FILE), "\n"),                      \
   assemble_name ((FILE), (NAME)),              \
-  fprintf ((FILE), ": .=.+ %d\n", (ROUNDED))           \
+  fprintf ((FILE), ": .=.+ %#ho\n", (unsigned short)(ROUNDED))         \
 )
 
 /* This says how to output an assembler line
@@ -1176,30 +1117,7 @@ fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n")       \
 
 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)  \
 ( assemble_name ((FILE), (NAME)),                              \
-  fprintf ((FILE), ":\t.=.+ %d\n", (ROUNDED)))
-
-/* Store in OUTPUT a string (made with alloca) containing
-   an assembler-name for a local static variable named NAME.
-   LABELNO is an integer which is different for each call.  */
-
-#define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
-( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),   \
-  sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
-
-/* Define the parentheses used to group arithmetic operations
-   in assembler code.  */
-
-#define ASM_OPEN_PAREN "("
-#define ASM_CLOSE_PAREN ")"
-
-/* Define results of standard character escape sequences.  */
-#define TARGET_BELL 007
-#define TARGET_BS 010
-#define TARGET_TAB 011
-#define TARGET_NEWLINE 012
-#define TARGET_VT 013
-#define TARGET_FF 014
-#define TARGET_CR 015
+  fprintf ((FILE), ":\t.=.+ %#ho\n", (unsigned short)(ROUNDED)))
 
 /* Print operand X (an rtx) in assembler syntax to file FILE.
    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
@@ -1215,10 +1133,10 @@ fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n")      \
   else if (GET_CODE (X) == MEM)                                                \
     output_address (XEXP (X, 0));                                      \
   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != SImode)     \
-    { union { double d; int i[2]; } u;                                 \
-      u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X);   \
-      fprintf (FILE, "#%.20e", u.d); }                                 \
-  else { putc ('$', FILE); output_addr_const (FILE, X); }}
+    { char buf[30];                                                    \
+      real_to_decimal (buf, CONST_DOUBLE_REAL_VALUE (X), sizeof (buf), 0, 1); \
+      fprintf (FILE, "$0F%s", buf); }                                  \
+  else { putc ('$', FILE); output_addr_const_pdp11 (FILE, X); }}
 \f
 /* Print a memory address as an operand to reference that memory location.  */
 
@@ -1235,12 +1153,6 @@ fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n")       \
   fprintf (FILE, "\tmov (sp)+, %s\n", reg_names[REGNO])        \
 )
 
-
-#define ASM_IDENTIFY_GCC(FILE)                 \
-    fprintf(FILE, "gcc_compiled:\n")
-
-#define ASM_OUTPUT_DOUBLE_INT(a,b)     fprintf(a,"%d", b)
-
 /* trampoline - how should i do it in separate i+d ? 
    have some allocate_trampoline magic??? 
 
@@ -1256,14 +1168,14 @@ JMP     FUNCTION        0x0058  0x0000 <- FUNCTION
   if (TARGET_SPLIT)                    \
     abort();                           \
                                        \
-  ASM_OUTPUT_INT (FILE, GEN_INT (0x9400+STATIC_CHAIN_REGNUM)); \
-  ASM_OUTPUT_INT (FILE, const0_rtx);                           \
-  ASM_OUTPUT_INT (FILE, GEN_INT(0x0058));                      \
-  ASM_OUTPUT_INT (FILE, const0_rtx);                           \
+  assemble_aligned_integer (2, GEN_INT (0x9400+STATIC_CHAIN_REGNUM));  \
+  assemble_aligned_integer (2, const0_rtx);                            \
+  assemble_aligned_integer (2, GEN_INT(0x0058));                       \
+  assemble_aligned_integer (2, const0_rtx);                            \
 }
 
 #define TRAMPOLINE_SIZE 8
-#define TRAMPOLINE_ALIGN 16
+#define TRAMPOLINE_ALIGNMENT 16
 
 /* Emit RTL insns to initialize the variable parts of a trampoline.
    FNADDR is an RTX for the address of the function's pure code.
@@ -1274,8 +1186,8 @@ JMP       FUNCTION        0x0058  0x0000 <- FUNCTION
   if (TARGET_SPLIT)                    \
     abort();                           \
                                        \
-  emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 2)), CXT); \
-  emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 6)), FNADDR); \
+  emit_move_insn (gen_rtx_MEM (HImode, plus_constant (TRAMP, 2)), CXT); \
+  emit_move_insn (gen_rtx_MEM (HImode, plus_constant (TRAMP, 6)), FNADDR); \
 }
 
 
@@ -1390,4 +1302,3 @@ JMP       FUNCTION        0x0058  0x0000 <- FUNCTION
 
 
 #define COMPARE_FLAG_MODE HImode
-