gcc/config/moxie/moxie.cc

   1 /* Target Code for moxie
   2    Copyright (C) 2008-2024 Free Software Foundation, Inc.
   3    Contributed by Anthony Green.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published
   9    by the Free Software Foundation; either version 3, or (at your
  10    option) any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING3.  If not see
  19    <http://www.gnu.org/licenses/>.  */
  20
  21 #define IN_TARGET_CODE 1
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "backend.h"
  27 #include "target.h"
  28 #include "rtl.h"
  29 #include "tree.h"
  30 #include "stringpool.h"
  31 #include "attribs.h"
  32 #include "df.h"
  33 #include "regs.h"
  34 #include "memmodel.h"
  35 #include "emit-rtl.h"
  36 #include "diagnostic-core.h"
  37 #include "output.h"
  38 #include "stor-layout.h"
  39 #include "varasm.h"
  40 #include "calls.h"
  41 #include "expr.h"
  42 #include "builtins.h"
  43
  44 /* This file should be included last.  */
  45 #include "target-def.h"
  46
  47 #define LOSE_AND_RETURN(msgid, x)               \
  48   do                                            \
  49     {                                           \
  50       moxie_operand_lossage (msgid, x);         \
  51       return;                                   \
  52     } while (0)
  53
  54 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
  55
  56 static bool
  57 moxie_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
  58 {
  59   const HOST_WIDE_INT size = int_size_in_bytes (type);
  60   return (size == -1 || size > 2 * UNITS_PER_WORD);
  61 }
  62
  63 /* Define how to find the value returned by a function.
  64    VALTYPE is the data type of the value (as a tree).
  65    If the precise function being called is known, FUNC is its
  66    FUNCTION_DECL; otherwise, FUNC is 0.
  67
  68    We always return values in register $r0 for moxie.  */
  69
  70 static rtx
  71 moxie_function_value (const_tree valtype,
  72                       const_tree fntype_or_decl ATTRIBUTE_UNUSED,
  73                       bool outgoing ATTRIBUTE_UNUSED)
  74 {
  75   return gen_rtx_REG (TYPE_MODE (valtype), MOXIE_R0);
  76 }
  77
  78 /* Define how to find the value returned by a library function.
  79
  80    We always return values in register $r0 for moxie.  */
  81
  82 static rtx
  83 moxie_libcall_value (machine_mode mode,
  84                      const_rtx fun ATTRIBUTE_UNUSED)
  85 {
  86   return gen_rtx_REG (mode, MOXIE_R0);
  87 }
  88
  89 /* Handle TARGET_FUNCTION_VALUE_REGNO_P.
  90
  91    We always return values in register $r0 for moxie.  */
  92
  93 static bool
  94 moxie_function_value_regno_p (const unsigned int regno)
  95 {
  96   return (regno == MOXIE_R0);
  97 }
  98
  99 /* Emit an error message when we're in an asm, and a fatal error for
 100    "normal" insns.  Formatted output isn't easily implemented, since we
 101    use output_operand_lossage to output the actual message and handle the
 102    categorization of the error.  */
 103
 104 static void
 105 moxie_operand_lossage (const char *msgid, rtx op)
 106 {
 107   debug_rtx (op);
 108   output_operand_lossage ("%s", msgid);
 109 }
 110
 111 /* The PRINT_OPERAND_ADDRESS worker.  */
 112
 113 static void
 114 moxie_print_operand_address (FILE *file, machine_mode, rtx x)
 115 {
 116   switch (GET_CODE (x))
 117     {
 118     case REG:
 119       fprintf (file, "(%s)", reg_names[REGNO (x)]);
 120       break;
 121
 122     case PLUS:
 123       switch (GET_CODE (XEXP (x, 1)))
 124         {
 125         case CONST_INT:
 126           fprintf (file, "%ld(%s)",
 127                    INTVAL(XEXP (x, 1)), reg_names[REGNO (XEXP (x, 0))]);
 128           break;
 129         case SYMBOL_REF:
 130           output_addr_const (file, XEXP (x, 1));
 131           fprintf (file, "(%s)", reg_names[REGNO (XEXP (x, 0))]);
 132           break;
 133         case CONST:
 134           {
 135             rtx plus = XEXP (XEXP (x, 1), 0);
 136             if (GET_CODE (XEXP (plus, 0)) == SYMBOL_REF
 137                 && CONST_INT_P (XEXP (plus, 1)))
 138               {
 139                 output_addr_const(file, XEXP (plus, 0));
 140                 fprintf (file,"+%ld(%s)", INTVAL (XEXP (plus, 1)),
 141                          reg_names[REGNO (XEXP (x, 0))]);
 142               }
 143             else
 144               abort();
 145           }
 146           break;
 147         default:
 148           abort();
 149         }
 150       break;
 151
 152     default:
 153       output_addr_const (file, x);
 154       break;
 155     }
 156 }
 157
 158 /* The PRINT_OPERAND worker.  */
 159
 160 static void
 161 moxie_print_operand (FILE *file, rtx x, int code)
 162 {
 163   rtx operand = x;
 164
 165   /* New code entries should just be added to the switch below.  If
 166      handling is finished, just return.  If handling was just a
 167      modification of the operand, the modified operand should be put in
 168      "operand", and then do a break to let default handling
 169      (zero-modifier) output the operand.  */
 170
 171   switch (code)
 172     {
 173     case 0:
 174       /* No code, print as usual.  */
 175       break;
 176
 177     default:
 178       LOSE_AND_RETURN ("invalid operand modifier letter", x);
 179     }
 180
 181   /* Print an operand as without a modifier letter.  */
 182   switch (GET_CODE (operand))
 183     {
 184     case REG:
 185       if (REGNO (operand) > MOXIE_R13)
 186         internal_error ("internal error: bad register: %d", REGNO (operand));
 187       fprintf (file, "%s", reg_names[REGNO (operand)]);
 188       return;
 189
 190     case MEM:
 191       output_address (GET_MODE (XEXP (operand, 0)), XEXP (operand, 0));
 192       return;
 193
 194     default:
 195       /* No need to handle all strange variants, let output_addr_const
 196          do it for us.  */
 197       if (CONSTANT_P (operand))
 198         {
 199           output_addr_const (file, operand);
 200           return;
 201         }
 202
 203       LOSE_AND_RETURN ("unexpected operand", x);
 204     }
 205 }
 206
 207 /* Per-function machine data.  */
 208 struct GTY(()) machine_function
 209  {
 210    /* Number of bytes saved on the stack for callee saved registers.  */
 211    int callee_saved_reg_size;
 212
 213    /* Number of bytes saved on the stack for local variables.  */
 214    int local_vars_size;
 215
 216    /* The sum of 2 sizes: locals vars and padding byte for saving the
 217     * registers.  Used in expand_prologue () and expand_epilogue().  */
 218    int size_for_adjusting_sp;
 219  };
 220
 221 /* Zero initialization is OK for all current fields.  */
 222
 223 static struct machine_function *
 224 moxie_init_machine_status (void)
 225 {
 226   return ggc_cleared_alloc<machine_function> ();
 227 }
 228
 229
 230 /* The TARGET_OPTION_OVERRIDE worker.  */
 231 static void
 232 moxie_option_override (void)
 233 {
 234   /* Set the per-function-data initializer.  */
 235   init_machine_status = moxie_init_machine_status;
 236
 237 #ifdef TARGET_MOXIEBOX
 238   target_flags |= MASK_HAS_MULX;
 239 #endif
 240 }
 241
 242 /* Compute the size of the local area and the size to be adjusted by the
 243  * prologue and epilogue.  */
 244
 245 static void
 246 moxie_compute_frame (void)
 247 {
 248   /* For aligning the local variables.  */
 249   int stack_alignment = STACK_BOUNDARY / BITS_PER_UNIT;
 250   int padding_locals;
 251   int regno;
 252
 253   /* Padding needed for each element of the frame.  */
 254   cfun->machine->local_vars_size = get_frame_size ();
 255
 256   /* Align to the stack alignment.  */
 257   padding_locals = cfun->machine->local_vars_size % stack_alignment;
 258   if (padding_locals)
 259     padding_locals = stack_alignment - padding_locals;
 260
 261   cfun->machine->local_vars_size += padding_locals;
 262
 263   cfun->machine->callee_saved_reg_size = 0;
 264
 265   /* Save callee-saved registers.  */
 266   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 267     if (df_regs_ever_live_p (regno) && (! call_used_or_fixed_reg_p (regno)))
 268       cfun->machine->callee_saved_reg_size += 4;
 269
 270   cfun->machine->size_for_adjusting_sp =
 271     crtl->args.pretend_args_size
 272     + cfun->machine->local_vars_size
 273     + (ACCUMULATE_OUTGOING_ARGS
 274        ? (HOST_WIDE_INT) crtl->outgoing_args_size : 0);
 275 }
 276
 277 void
 278 moxie_expand_prologue (void)
 279 {
 280   int regno;
 281   rtx insn;
 282
 283   moxie_compute_frame ();
 284
 285   if (flag_stack_usage_info)
 286     current_function_static_stack_size = cfun->machine->size_for_adjusting_sp;
 287
 288   /* Save callee-saved registers.  */
 289   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 290     {
 291       if (df_regs_ever_live_p (regno)
 292           && !call_used_or_fixed_reg_p (regno))
 293         {
 294           insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode, regno)));
 295           RTX_FRAME_RELATED_P (insn) = 1;
 296         }
 297     }
 298
 299   if (cfun->machine->size_for_adjusting_sp > 0)
 300     {
 301       int i = cfun->machine->size_for_adjusting_sp;
 302       while ((i >= 255) && (i <= 510))
 303         {
 304           insn = emit_insn (gen_subsi3 (stack_pointer_rtx,
 305                                         stack_pointer_rtx,
 306                                         GEN_INT (255)));
 307           RTX_FRAME_RELATED_P (insn) = 1;
 308           i -= 255;
 309         }
 310       if (i <= 255)
 311         {
 312           insn = emit_insn (gen_subsi3 (stack_pointer_rtx,
 313                                         stack_pointer_rtx,
 314                                         GEN_INT (i)));
 315           RTX_FRAME_RELATED_P (insn) = 1;
 316         }
 317       else
 318         {
 319           rtx reg = gen_rtx_REG (SImode, MOXIE_R12);
 320           insn = emit_move_insn (reg, GEN_INT (i));
 321           RTX_FRAME_RELATED_P (insn) = 1;
 322           insn = emit_insn (gen_subsi3 (stack_pointer_rtx,
 323                                         stack_pointer_rtx,
 324                                         reg));
 325           RTX_FRAME_RELATED_P (insn) = 1;
 326         }
 327     }
 328 }
 329
 330 void
 331 moxie_expand_epilogue (void)
 332 {
 333   int regno;
 334   rtx reg;
 335
 336   if (cfun->machine->callee_saved_reg_size != 0)
 337     {
 338       reg = gen_rtx_REG (Pmode, MOXIE_R12);
 339       if (cfun->machine->callee_saved_reg_size <= 255)
 340         {
 341           emit_move_insn (reg, hard_frame_pointer_rtx);
 342           emit_insn (gen_subsi3
 343                      (reg, reg,
 344                       GEN_INT (cfun->machine->callee_saved_reg_size)));
 345         }
 346       else
 347         {
 348           emit_move_insn (reg,
 349                           GEN_INT (-cfun->machine->callee_saved_reg_size));
 350           emit_insn (gen_addsi3 (reg, reg, hard_frame_pointer_rtx));
 351         }
 352       for (regno = FIRST_PSEUDO_REGISTER; regno-- > 0; )
 353         if (!call_used_or_fixed_reg_p (regno)
 354             && df_regs_ever_live_p (regno))
 355           {
 356             rtx preg = gen_rtx_REG (Pmode, regno);
 357             emit_insn (gen_movsi_pop (reg, preg));
 358           }
 359     }
 360
 361   emit_jump_insn (gen_returner ());
 362 }
 363
 364 /* Implements the macro INITIAL_ELIMINATION_OFFSET, return the OFFSET.  */
 365
 366 int
 367 moxie_initial_elimination_offset (int from, int to)
 368 {
 369   int ret;
 370
 371   if ((from) == FRAME_POINTER_REGNUM && (to) == HARD_FRAME_POINTER_REGNUM)
 372     {
 373       /* Compute this since we need to use cfun->machine->local_vars_size.  */
 374       moxie_compute_frame ();
 375       ret = -cfun->machine->callee_saved_reg_size;
 376     }
 377   else if ((from) == ARG_POINTER_REGNUM && (to) == HARD_FRAME_POINTER_REGNUM)
 378     ret = 0x00;
 379   else
 380     abort ();
 381
 382   return ret;
 383 }
 384
 385 /* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */
 386
 387 static void
 388 moxie_setup_incoming_varargs (cumulative_args_t cum_v,
 389                               const function_arg_info &,
 390                               int *pretend_size, int no_rtl)
 391 {
 392   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 393   int regno;
 394   int regs = 8 - *cum;
 395
 396   *pretend_size = regs < 0 ? 0 : GET_MODE_SIZE (SImode) * regs;
 397
 398   if (no_rtl)
 399     return;
 400
 401   for (regno = *cum; regno < 8; regno++)
 402     {
 403       rtx reg = gen_rtx_REG (SImode, regno);
 404       rtx slot = gen_rtx_PLUS (Pmode,
 405                                gen_rtx_REG (SImode, ARG_POINTER_REGNUM),
 406                                GEN_INT (UNITS_PER_WORD * (3 + (regno-2))));
 407
 408       emit_move_insn (gen_rtx_MEM (SImode, slot), reg);
 409     }
 410 }
 411
 412
 413 /* Return the fixed registers used for condition codes.  */
 414
 415 static bool
 416 moxie_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
 417 {
 418   *p1 = CC_REG;
 419   *p2 = INVALID_REGNUM;
 420   return true;
 421 }
 422
 423 /* Return the next register to be used to hold a function argument or
 424    NULL_RTX if there's no more space.  */
 425
 426 static rtx
 427 moxie_function_arg (cumulative_args_t cum_v, const function_arg_info &arg)
 428 {
 429   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 430
 431   if (*cum < 8)
 432     return gen_rtx_REG (arg.mode, *cum);
 433   else
 434     return NULL_RTX;
 435 }
 436
 437 #define MOXIE_FUNCTION_ARG_SIZE(MODE, TYPE)     \
 438   ((MODE) != BLKmode ? GET_MODE_SIZE (MODE)     \
 439    : (unsigned) int_size_in_bytes (TYPE))
 440
 441 static void
 442 moxie_function_arg_advance (cumulative_args_t cum_v,
 443                             const function_arg_info &arg)
 444 {
 445   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 446
 447   *cum = (*cum < MOXIE_R6
 448           ? *cum + ((3 + MOXIE_FUNCTION_ARG_SIZE (arg.mode, arg.type)) / 4)
 449           : *cum);
 450 }
 451
 452 /* Return non-zero if the function argument described by ARG is to be
 453    passed by reference.  */
 454
 455 static bool
 456 moxie_pass_by_reference (cumulative_args_t, const function_arg_info &arg)
 457 {
 458   if (arg.aggregate_type_p ())
 459     return true;
 460   unsigned HOST_WIDE_INT size = arg.type_size_in_bytes ();
 461   return size > 4*6;
 462 }
 463
 464 /* Some function arguments will only partially fit in the registers
 465    that hold arguments.  Given a new arg, return the number of bytes
 466    that fit in argument passing registers.  */
 467
 468 static int
 469 moxie_arg_partial_bytes (cumulative_args_t cum_v, const function_arg_info &arg)
 470 {
 471   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 472   int bytes_left, size;
 473
 474   if (*cum >= 8)
 475     return 0;
 476
 477   if (moxie_pass_by_reference (cum_v, arg))
 478     size = 4;
 479   else if (arg.type)
 480     {
 481       if (AGGREGATE_TYPE_P (arg.type))
 482         return 0;
 483       size = int_size_in_bytes (arg.type);
 484     }
 485   else
 486     size = GET_MODE_SIZE (arg.mode);
 487
 488   bytes_left = (4 * 6) - ((*cum - 2) * 4);
 489
 490   if (size > bytes_left)
 491     return bytes_left;
 492   else
 493     return 0;
 494 }
 495
 496 /* Worker function for TARGET_STATIC_CHAIN.  */
 497
 498 static rtx
 499 moxie_static_chain (const_tree ARG_UNUSED (fndecl_or_type), bool incoming_p)
 500 {
 501   rtx addr, mem;
 502
 503   if (incoming_p)
 504     addr = plus_constant (Pmode, arg_pointer_rtx, 2 * UNITS_PER_WORD);
 505   else
 506     addr = plus_constant (Pmode, stack_pointer_rtx, -UNITS_PER_WORD);
 507
 508   mem = gen_rtx_MEM (Pmode, addr);
 509   MEM_NOTRAP_P (mem) = 1;
 510
 511   return mem;
 512 }
 513
 514 /* Worker function for TARGET_ASM_TRAMPOLINE_TEMPLATE.  */
 515
 516 static void
 517 moxie_asm_trampoline_template (FILE *f)
 518 {
 519   fprintf (f, "\tpush  $sp, $r0\n");
 520   fprintf (f, "\tldi.l $r0, 0x0\n");
 521   fprintf (f, "\tsto.l 0x8($fp), $r0\n");
 522   fprintf (f, "\tpop   $sp, $r0\n");
 523   fprintf (f, "\tjmpa  0x0\n");
 524 }
 525
 526 /* Worker function for TARGET_TRAMPOLINE_INIT.  */
 527
 528 static void
 529 moxie_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
 530 {
 531   rtx mem, fnaddr = XEXP (DECL_RTL (fndecl), 0);
 532
 533   emit_block_move (m_tramp, assemble_trampoline_template (),
 534                    GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
 535
 536   mem = adjust_address (m_tramp, SImode, 4);
 537   emit_move_insn (mem, chain_value);
 538   mem = adjust_address (m_tramp, SImode, 16);
 539   emit_move_insn (mem, fnaddr);
 540 }
 541
 542 /* Return true for memory offset addresses between -32768 and 32767.  */
 543 bool
 544 moxie_offset_address_p (rtx x)
 545 {
 546   x = XEXP (x, 0);
 547
 548   if (GET_CODE (x) == PLUS)
 549     {
 550       x = XEXP (x, 1);
 551       if (GET_CODE (x) == CONST_INT)
 552         {
 553           unsigned int v = INTVAL (x) & 0xFFFF8000;
 554           return (v == 0xFFFF8000 || v == 0x00000000);
 555         }
 556     }
 557   return 0;
 558 }
 559
 560 /* Helper function for `moxie_legitimate_address_p'.  */
 561
 562 static bool
 563 moxie_reg_ok_for_base_p (const_rtx reg, bool strict_p)
 564 {
 565   int regno = REGNO (reg);
 566
 567   if (strict_p)
 568     return HARD_REGNO_OK_FOR_BASE_P (regno)
 569            || HARD_REGNO_OK_FOR_BASE_P (reg_renumber[regno]);
 570   else
 571     return !HARD_REGISTER_NUM_P (regno)
 572            || HARD_REGNO_OK_FOR_BASE_P (regno);
 573 }
 574
 575 /* Worker function for TARGET_LEGITIMATE_ADDRESS_P.  */
 576
 577 static bool
 578 moxie_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
 579                             rtx x, bool strict_p,
 580                             addr_space_t as,
 581                             code_helper = ERROR_MARK)
 582 {
 583   gcc_assert (ADDR_SPACE_GENERIC_P (as));
 584
 585   if (GET_CODE(x) == PLUS
 586       && REG_P (XEXP (x, 0))
 587       && moxie_reg_ok_for_base_p (XEXP (x, 0), strict_p)
 588       && CONST_INT_P (XEXP (x, 1))
 589       && IN_RANGE (INTVAL (XEXP (x, 1)), -32768, 32767))
 590     return true;
 591   if (REG_P (x) && moxie_reg_ok_for_base_p (x, strict_p))
 592     return true;
 593   if (GET_CODE (x) == SYMBOL_REF
 594       || GET_CODE (x) == LABEL_REF
 595       || GET_CODE (x) == CONST)
 596     return true;
 597   return false;
 598 }
 599
 600 /* The Global `targetm' Variable.  */
 601
 602 /* Initialize the GCC target structure.  */
 603
 604 #undef  TARGET_PROMOTE_PROTOTYPES
 605 #define TARGET_PROMOTE_PROTOTYPES       hook_bool_const_tree_true
 606
 607 #undef  TARGET_RETURN_IN_MEMORY
 608 #define TARGET_RETURN_IN_MEMORY         moxie_return_in_memory
 609 #undef  TARGET_MUST_PASS_IN_STACK
 610 #define TARGET_MUST_PASS_IN_STACK       must_pass_in_stack_var_size
 611 #undef  TARGET_PASS_BY_REFERENCE
 612 #define TARGET_PASS_BY_REFERENCE        moxie_pass_by_reference
 613 #undef  TARGET_ARG_PARTIAL_BYTES
 614 #define TARGET_ARG_PARTIAL_BYTES        moxie_arg_partial_bytes
 615 #undef  TARGET_FUNCTION_ARG
 616 #define TARGET_FUNCTION_ARG             moxie_function_arg
 617 #undef  TARGET_FUNCTION_ARG_ADVANCE
 618 #define TARGET_FUNCTION_ARG_ADVANCE     moxie_function_arg_advance
 619
 620 #undef  TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P
 621 #define TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P  moxie_legitimate_address_p
 622
 623 #undef  TARGET_SETUP_INCOMING_VARARGS
 624 #define TARGET_SETUP_INCOMING_VARARGS   moxie_setup_incoming_varargs
 625
 626 #undef  TARGET_FIXED_CONDITION_CODE_REGS
 627 #define TARGET_FIXED_CONDITION_CODE_REGS moxie_fixed_condition_code_regs
 628
 629 /* Define this to return an RTX representing the place where a
 630    function returns or receives a value of data type RET_TYPE, a tree
 631    node representing a data type.  */
 632 #undef TARGET_FUNCTION_VALUE
 633 #define TARGET_FUNCTION_VALUE moxie_function_value
 634 #undef TARGET_LIBCALL_VALUE
 635 #define TARGET_LIBCALL_VALUE moxie_libcall_value
 636 #undef TARGET_FUNCTION_VALUE_REGNO_P
 637 #define TARGET_FUNCTION_VALUE_REGNO_P moxie_function_value_regno_p
 638
 639 #undef TARGET_FRAME_POINTER_REQUIRED
 640 #define TARGET_FRAME_POINTER_REQUIRED hook_bool_void_true
 641
 642 #undef TARGET_STATIC_CHAIN
 643 #define TARGET_STATIC_CHAIN moxie_static_chain
 644 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
 645 #define TARGET_ASM_TRAMPOLINE_TEMPLATE moxie_asm_trampoline_template
 646 #undef TARGET_TRAMPOLINE_INIT
 647 #define TARGET_TRAMPOLINE_INIT moxie_trampoline_init
 648
 649 #undef TARGET_OPTION_OVERRIDE
 650 #define TARGET_OPTION_OVERRIDE moxie_option_override
 651
 652 #undef  TARGET_PRINT_OPERAND
 653 #define TARGET_PRINT_OPERAND moxie_print_operand
 654 #undef  TARGET_PRINT_OPERAND_ADDRESS
 655 #define TARGET_PRINT_OPERAND_ADDRESS moxie_print_operand_address
 656
 657 #undef  TARGET_CONSTANT_ALIGNMENT
 658 #define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
 659
 660 struct gcc_target targetm = TARGET_INITIALIZER;
 661
 662 #include "gt-moxie.h"