toolchain/gcc/patches/4.5.1+l/600-ubicom_support.patch

   1 --- a/configure
   2 +++ b/configure
   3 @@ -2688,6 +2688,9 @@ case "${target}" in
   4    ip2k-*-*)
   5      noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
   6      ;;
   7 +  ubicom32-*-*)
   8 +    noconfigdirs="$noconfigdirs target-libffi"
   9 +    ;;
  10    *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
  11      noconfigdirs="$noconfigdirs target-newlib target-libgloss"
  12      ;;
  13 --- /dev/null
  14 +++ b/gcc/config/ubicom32/constraints.md
  15 @@ -0,0 +1,149 @@
  16 +; Constraint definitions for Ubicom32
  17 +
  18 +; Copyright (C) 2009 Free Software Foundation, Inc.
  19 +; Contributed by Ubicom, Inc.
  20 +
  21 +; This file is part of GCC.
  22 +
  23 +; GCC is free software; you can redistribute it and/or modify it
  24 +; under the terms of the GNU General Public License as published
  25 +; by the Free Software Foundation; either version 3, or (at your
  26 +; option) any later version.
  27 +
  28 +; GCC is distributed in the hope that it will be useful, but WITHOUT
  29 +; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  30 +; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  31 +; License for more details.
  32 +
  33 +; You should have received a copy of the GNU General Public License
  34 +; along with GCC; see the file COPYING3.  If not see
  35 +; <http://www.gnu.org/licenses/>.
  36 +
  37 +(define_register_constraint "a" "ALL_ADDRESS_REGS"
  38 +  "An An register.")
  39 +
  40 +(define_register_constraint "d" "DATA_REGS"
  41 +  "A Dn register.")
  42 +
  43 +(define_register_constraint "h" "ACC_REGS"
  44 +  "An accumulator register.")
  45 +
  46 +(define_register_constraint "l" "ACC_LO_REGS"
  47 +  "An accn_lo register.")
  48 +
  49 +(define_register_constraint "Z" "FDPIC_REG"
  50 +  "The FD-PIC GOT pointer: A0.")
  51 +
  52 +(define_constraint "I"
  53 +  "An 8-bit signed constant value."
  54 +  (and (match_code "const_int")
  55 +       (match_test "(ival >= -128) && (ival <= 127)")))
  56 +
  57 +(define_constraint "Q"
  58 +  "An 8-bit signed constant value represented as unsigned."
  59 +  (and (match_code "const_int")
  60 +       (match_test "(ival >= 0x00) && (ival <= 0xff)")))
  61 +
  62 +(define_constraint "R"
  63 +  "An 8-bit signed constant value represented as unsigned."
  64 +  (and (match_code "const_int")
  65 +       (match_test "((ival >= 0x0000) && (ival <= 0x007f)) || ((ival >= 0xff80) && (ival <= 0xffff))")))
  66 +
  67 +(define_constraint "J"
  68 +  "A 7-bit unsigned constant value."
  69 +  (and (match_code "const_int")
  70 +       (match_test "(ival >= 0) && (ival <= 127)")))
  71 +
  72 +(define_constraint "K"
  73 +  "A 7-bit unsigned constant value shifted << 1."
  74 +  (and (match_code "const_int")
  75 +       (match_test "(ival >= 0) && (ival <= 254) && ((ival & 1) == 0)")))
  76 +
  77 +(define_constraint "L"
  78 +  "A 7-bit unsigned constant value shifted << 2."
  79 +  (and (match_code "const_int")
  80 +       (match_test "(ival >= 0) && (ival <= 508) && ((ival & 3) == 0)")))
  81 +
  82 +(define_constraint "M"
  83 +  "A 5-bit unsigned constant value."
  84 +  (and (match_code "const_int")
  85 +       (match_test "(ival >= 0) && (ival <= 31)")))
  86 +
  87 +(define_constraint "N"
  88 +  "A signed 16 bit constant value."
  89 +  (and (match_code "const_int")
  90 +       (match_test "(ival >= -32768) && (ival <= 32767)")))
  91 +
  92 +(define_constraint "O"
  93 +  "An exact bitmask of contiguous 1 bits starting at bit 0."
  94 +  (and (match_code "const_int")
  95 +       (match_test "exact_log2 (ival + 1) != -1")))
  96 +
  97 +(define_constraint "P"
  98 +  "A 7-bit negative constant value shifted << 2."
  99 +  (and (match_code "const_int")
 100 +       (match_test "(ival >= -504) && (ival <= 0) && ((ival & 3) == 0)")))
 101 +
 102 +(define_constraint "S"
 103 +  "A symbolic reference."
 104 +  (match_code "symbol_ref"))
 105 +
 106 +(define_constraint "Y"
 107 +  "An FD-PIC symbolic reference."
 108 +  (and (match_test "TARGET_FDPIC")
 109 +       (match_test "GET_CODE (op) == UNSPEC")
 110 +       (ior (match_test "XINT (op, 1) == UNSPEC_FDPIC_GOT")
 111 +           (match_test "XINT (op, 1) == UNSPEC_FDPIC_GOT_FUNCDESC"))))
 112 +
 113 +(define_memory_constraint "T1"
 114 +  "A memory operand that can be used for .1 instruction."
 115 +  (and (match_test "memory_operand (op, GET_MODE(op))")
 116 +       (match_test "GET_MODE (op) == QImode")))
 117 +
 118 +(define_memory_constraint "T2"
 119 +  "A memory operand that can be used for .2 instruction."
 120 +  (and (match_test "memory_operand (op, GET_MODE(op))")
 121 +       (match_test "GET_MODE (op) == HImode")))
 122 +
 123 +(define_memory_constraint "T4"
 124 +  "A memory operand that can be used for .4 instruction."
 125 +  (and (match_test "memory_operand (op, GET_MODE(op))")
 126 +       (ior (match_test "GET_MODE (op) == SImode")
 127 +           (match_test "GET_MODE (op) == DImode")
 128 +           (match_test "GET_MODE (op) == SFmode"))))
 129 +
 130 +(define_memory_constraint "U1"
 131 +  "An offsettable memory operand that can be used for .1 instruction."
 132 +  (and (match_test "memory_operand (op, GET_MODE(op))")
 133 +       (match_test "GET_MODE (op) == QImode")
 134 +       (match_test "GET_CODE (XEXP (op, 0)) != POST_INC")
 135 +       (match_test "GET_CODE (XEXP (op, 0)) != PRE_INC")
 136 +       (match_test "GET_CODE (XEXP (op, 0)) != POST_DEC")
 137 +       (match_test "GET_CODE (XEXP (op, 0)) != PRE_DEC")
 138 +       (match_test "GET_CODE (XEXP (op, 0)) != POST_MODIFY")
 139 +       (match_test "GET_CODE (XEXP (op, 0)) != PRE_MODIFY")))
 140 +
 141 +(define_memory_constraint "U2"
 142 +  "An offsettable memory operand that can be used for .2 instruction."
 143 +  (and (match_test "memory_operand (op, GET_MODE(op))")
 144 +       (match_test "GET_MODE (op) == HImode")
 145 +       (match_test "GET_CODE (XEXP (op, 0)) != POST_INC")
 146 +       (match_test "GET_CODE (XEXP (op, 0)) != PRE_INC")
 147 +       (match_test "GET_CODE (XEXP (op, 0)) != POST_DEC")
 148 +       (match_test "GET_CODE (XEXP (op, 0)) != PRE_DEC")
 149 +       (match_test "GET_CODE (XEXP (op, 0)) != POST_MODIFY")
 150 +       (match_test "GET_CODE (XEXP (op, 0)) != PRE_MODIFY")))
 151 +
 152 +(define_memory_constraint "U4"
 153 +  "An offsettable memory operand that can be used for .4 instruction."
 154 +  (and (match_test "memory_operand (op, GET_MODE(op))")
 155 +       (ior (match_test "GET_MODE (op) == SImode")
 156 +           (match_test "GET_MODE (op) == DImode")
 157 +           (match_test "GET_MODE (op) == SFmode"))
 158 +       (match_test "GET_CODE (XEXP (op, 0)) != POST_INC")
 159 +       (match_test "GET_CODE (XEXP (op, 0)) != PRE_INC")
 160 +       (match_test "GET_CODE (XEXP (op, 0)) != POST_DEC")
 161 +       (match_test "GET_CODE (XEXP (op, 0)) != PRE_DEC")
 162 +       (match_test "GET_CODE (XEXP (op, 0)) != POST_MODIFY")
 163 +       (match_test "GET_CODE (XEXP (op, 0)) != PRE_MODIFY")))
 164 +
 165 --- /dev/null
 166 +++ b/gcc/config/ubicom32/crti.S
 167 @@ -0,0 +1,54 @@
 168 +/* Specialized code needed to support construction and destruction of
 169 +   file-scope objects in C++ and Java code, and to support exception handling.
 170 +   Copyright (C) 1999 Free Software Foundation, Inc.
 171 +   Contributed by Charles-Antoine Gauthier (charles.gauthier@iit.nrc.ca).
 172 +
 173 +This file is part of GCC.
 174 +
 175 +GCC is free software; you can redistribute it and/or modify
 176 +it under the terms of the GNU General Public License as published by
 177 +the Free Software Foundation; either version 2, or (at your option)
 178 +any later version.
 179 +
 180 +GCC is distributed in the hope that it will be useful,
 181 +but WITHOUT ANY WARRANTY; without even the implied warranty of
 182 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 183 +GNU General Public License for more details.
 184 +
 185 +You should have received a copy of the GNU General Public License
 186 +along with GCC; see the file COPYING.  If not, write to
 187 +the Free Software Foundation, 59 Temple Place - Suite 330,
 188 +Boston, MA 02111-1307, USA.  */
 189 +
 190 +/* As a special exception, if you link this library with files
 191 +   compiled with GCC to produce an executable, this does not cause
 192 +   the resulting executable to be covered by the GNU General Public License.
 193 +   This exception does not however invalidate any other reasons why
 194 +   the executable file might be covered by the GNU General Public License.  */
 195 +
 196 +/*
 197 + * This file just supplies function prologues for the .init and .fini
 198 + * sections.  It is linked in before crtbegin.o.
 199 + */
 200 +       .file   "crti.o"
 201 +       .ident  "GNU C crti.o"
 202 +
 203 +       .section .init
 204 +       .align  2
 205 +       .globl  _init
 206 +       .type   _init, @function
 207 +_init:
 208 +       move.4 -4(sp)++, a5
 209 +#ifdef __UBICOM32_FDPIC__
 210 +       move.4 -4(sp)++, a0
 211 +#endif
 212 +
 213 +       .section .fini
 214 +       .align  2
 215 +       .globl  _fini
 216 +       .type   _fini, @function
 217 +_fini:
 218 +       move.4 -4(sp)++, a5
 219 +#ifdef __UBICOM32_FDPIC__
 220 +       move.4 -4(sp)++, a0
 221 +#endif
 222 --- /dev/null
 223 +++ b/gcc/config/ubicom32/crtn.S
 224 @@ -0,0 +1,47 @@
 225 +/* Specialized code needed to support construction and destruction of
 226 +   file-scope objects in C++ and Java code, and to support exception handling.
 227 +   Copyright (C) 1999 Free Software Foundation, Inc.
 228 +   Contributed by Charles-Antoine Gauthier (charles.gauthier@iit.nrc.ca).
 229 +
 230 +This file is part of GCC.
 231 +
 232 +GCC is free software; you can redistribute it and/or modify
 233 +it under the terms of the GNU General Public License as published by
 234 +the Free Software Foundation; either version 2, or (at your option)
 235 +any later version.
 236 +
 237 +GCC is distributed in the hope that it will be useful,
 238 +but WITHOUT ANY WARRANTY; without even the implied warranty of
 239 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 240 +GNU General Public License for more details.
 241 +
 242 +You should have received a copy of the GNU General Public License
 243 +along with GCC; see the file COPYING.  If not, write to
 244 +the Free Software Foundation, 59 Temple Place - Suite 330,
 245 +Boston, MA 02111-1307, USA.  */
 246 +
 247 +/* As a special exception, if you link this library with files
 248 +   compiled with GCC to produce an executable, this does not cause
 249 +   the resulting executable to be covered by the GNU General Public License.
 250 +   This exception does not however invalidate any other reasons why
 251 +   the executable file might be covered by the GNU General Public License.  */
 252 +
 253 +/*
 254 + * This file supplies function epilogues for the .init and .fini sections.
 255 + * It is linked in after all other files.
 256 + */
 257 +
 258 +       .file   "crtn.o"
 259 +       .ident  "GNU C crtn.o"
 260 +
 261 +       .section .init
 262 +#ifdef __UBICOM32_FDPIC__
 263 +       move.4  a0, (sp)4++
 264 +#endif
 265 +       ret     (sp)4++
 266 +
 267 +       .section .fini
 268 +#ifdef __UBICOM32_FDPIC__
 269 +       move.4  a0, (sp)4++
 270 +#endif
 271 +       ret     (sp)4++
 272 --- /dev/null
 273 +++ b/gcc/config/ubicom32/elf.h
 274 @@ -0,0 +1,29 @@
 275 +#undef  STARTFILE_SPEC
 276 +#define STARTFILE_SPEC "\
 277 +%{msim:%{!shared:crt0%O%s}} \
 278 +crti%O%s crtbegin%O%s"
 279 +
 280 +#undef  ENDFILE_SPEC
 281 +#define ENDFILE_SPEC   "crtend%O%s crtn%O%s"
 282 +
 283 +#ifdef __UBICOM32_FDPIC__
 284 +#define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC)                     \
 285 +  asm (SECTION_OP);                                                    \
 286 +  asm ("move.4 a0, 0(sp);\n\t"                                         \
 287 +       "call a5," USER_LABEL_PREFIX #FUNC ";");                                \
 288 +  asm (TEXT_SECTION_ASM_OP);
 289 +#endif
 290 +
 291 +#undef SUBTARGET_DRIVER_SELF_SPECS
 292 +#define SUBTARGET_DRIVER_SELF_SPECS \
 293 +     "%{mfdpic:-msim} "
 294 +
 295 +#define NO_IMPLICIT_EXTERN_C
 296 +
 297 +/*
 298 + * We need this to compile crtbegin/crtend. This should really be picked
 299 + * up from elfos.h but at the moment including elfos.h causes other more
 300 + * serous linker issues.
 301 + */
 302 +#define INIT_SECTION_ASM_OP    "\t.section\t.init"
 303 +#define FINI_SECTION_ASM_OP    "\t.section\t.fini"
 304 --- /dev/null
 305 +++ b/gcc/config/ubicom32/linux.h
 306 @@ -0,0 +1,80 @@
 307 +/* Definitions of target machine for Ubicom32-uclinux
 308 +
 309 +   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
 310 +   2009 Free Software Foundation, Inc.
 311 +   Contributed by Ubicom, Inc.
 312 +
 313 +   This file is part of GCC.
 314 +
 315 +   GCC is free software; you can redistribute it and/or modify it
 316 +   under the terms of the GNU General Public License as published
 317 +   by the Free Software Foundation; either version 3, or (at your
 318 +   option) any later version.
 319 +
 320 +   GCC is distributed in the hope that it will be useful, but WITHOUT
 321 +   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 322 +   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 323 +   License for more details.
 324 +
 325 +   You should have received a copy of the GNU General Public License
 326 +   along with GCC; see the file COPYING3.  If not see
 327 +   <http://www.gnu.org/licenses/>.  */
 328 +
 329 +/* Don't assume anything about the header files.  */
 330 +#define NO_IMPLICIT_EXTERN_C
 331 +
 332 +#undef  LIB_SPEC
 333 +#define LIB_SPEC  \
 334 +       "%{pthread:-lpthread} " \
 335 +       "-lc"
 336 +
 337 +#undef LINK_GCC_C_SEQUENCE_SPEC
 338 +#define LINK_GCC_C_SEQUENCE_SPEC \
 339 +  "%{static:--start-group} %G %L %{static:--end-group} " \
 340 +  "%{!static: %G}"
 341 +
 342 +#undef STARTFILE_SPEC
 343 +#define STARTFILE_SPEC \
 344 +  "%{!shared: %{pg|p|profile:gcrt1%O%s;pie:Scrt1%O%s;:crt1%O%s}} " \
 345 +  "crtreloc%O%s crti%O%s %{shared|pie:crtbeginS%O%s;:crtbegin%O%s}"
 346 +
 347 +#undef ENDFILE_SPEC
 348 +#define ENDFILE_SPEC \
 349 +  "%{shared|pie:crtendS%O%s;:crtend%O%s} crtn%O%s"
 350 +
 351 +/* taken from linux.h */
 352 +/* The GNU C++ standard library requires that these macros be defined.  */
 353 +#undef CPLUSPLUS_CPP_SPEC
 354 +#define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)"
 355 +
 356 +#define TARGET_OS_CPP_BUILTINS()                               \
 357 +    do {                                                       \
 358 +       builtin_define_std ("__UBICOM32__");                    \
 359 +       builtin_define_std ("__ubicom32__");                    \
 360 +       builtin_define ("__gnu_linux__");                       \
 361 +       builtin_define_std ("linux");                           \
 362 +       builtin_define_std ("unix");                            \
 363 +       builtin_assert ("system=linux");                        \
 364 +       builtin_assert ("system=unix");                         \
 365 +       builtin_assert ("system=posix");                        \
 366 +    } while (0)
 367 +
 368 +#define OBJECT_FORMAT_ELF
 369 +
 370 +
 371 +#undef DRIVER_SELF_SPECS
 372 +#define DRIVER_SELF_SPECS \
 373 +  "%{!mno-fdpic:-mfdpic}"
 374 +
 375 +#undef LINK_SPEC
 376 +#define LINK_SPEC "%{mfdpic: -m elf32ubicom32fdpic -z text } %{shared} %{pie} \
 377 +  %{static:-dn -Bstatic} \
 378 +  %{shared:-G -Bdynamic} \
 379 +  %{!shared: %{!static: \
 380 +   %{rdynamic:-export-dynamic} \
 381 +   %{!dynamic-linker:-dynamic-linker /lib/ld-uClibc.so.0}} \
 382 +   %{static}} "
 383 +
 384 +/*
 385 +#define MD_UNWIND_SUPPORT "config/bfin/linux-unwind.h"
 386 +*/
 387 --- /dev/null
 388 +++ b/gcc/config/ubicom32/predicates.md
 389 @@ -0,0 +1,327 @@
 390 +; Predicate definitions for Ubicom32.
 391 +
 392 +; Copyright (C) 2009 Free Software Foundation, Inc.
 393 +; Contributed by Ubicom, Inc.
 394 +
 395 +; This file is part of GCC.
 396 +
 397 +; GCC is free software; you can redistribute it and/or modify it
 398 +; under the terms of the GNU General Public License as published
 399 +; by the Free Software Foundation; either version 3, or (at your
 400 +; option) any later version.
 401 +
 402 +; GCC is distributed in the hope that it will be useful, but WITHOUT
 403 +; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 404 +; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 405 +; License for more details.
 406 +
 407 +; You should have received a copy of the GNU General Public License
 408 +; along with GCC; see the file COPYING3.  If not see
 409 +; <http://www.gnu.org/licenses/>.
 410 +
 411 +(define_predicate "ubicom32_move_operand"
 412 +  (match_code "const_int, const_double, const, mem, subreg, reg, lo_sum")
 413 +{
 414 +  if (CONST_INT_P (op))
 415 +    return true;
 416 +
 417 +  if (GET_CODE (op) == CONST_DOUBLE)
 418 +    return true;
 419 +
 420 +  if (GET_CODE (op) == CONST)
 421 +    return memory_address_p (mode, op);
 422 +
 423 +  if (GET_MODE (op) != mode)
 424 +    return false;
 425 +
 426 +  if (MEM_P (op))
 427 +    return memory_address_p (mode, XEXP (op, 0));
 428 +
 429 +  if (GET_CODE (op) == SUBREG) {
 430 +      op = SUBREG_REG (op);
 431 +
 432 +      if (REG_P (op))
 433 +       return true;
 434 +
 435 +      if (! MEM_P (op))
 436 +       return false;
 437 +
 438 +      /* Paradoxical SUBREG.  */
 439 +      if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (op)))
 440 +       return false;
 441 +
 442 +      return memory_address_p (GET_MODE (op), XEXP (op, 0));
 443 +    }
 444 +
 445 +  return register_operand (op, mode);
 446 +})
 447 +
 448 +;; Returns true if OP is either a symbol reference or a sum of a
 449 +;; symbol reference and a constant.
 450 +
 451 +(define_predicate "ubicom32_symbolic_address_operand"
 452 +  (match_code "symbol_ref, label_ref, const")
 453 +{
 454 +  switch (GET_CODE (op))
 455 +    {
 456 +    case SYMBOL_REF:
 457 +    case LABEL_REF:
 458 +      return true;
 459 +
 460 +    case CONST:
 461 +      op = XEXP (op, 0);
 462 +      return ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
 463 +              || GET_CODE (XEXP (op, 0)) == LABEL_REF)
 464 +             && CONST_INT_P (XEXP (op, 1)));
 465 +
 466 +    default:
 467 +      return false;
 468 +    }
 469 +})
 470 +
 471 +;; Return true if operand is the uClinux FD-PIC register.
 472 +
 473 +(define_predicate "ubicom32_fdpic_operand"
 474 +  (match_code "reg")
 475 +{
 476 +  if (! TARGET_FDPIC)
 477 +    return false;
 478 +
 479 +  if (!REG_P (op))
 480 +    return false;
 481 +
 482 +  if (GET_MODE (op) != mode && mode != VOIDmode)
 483 +    return false;
 484 +
 485 +  if (REGNO (op) != FDPIC_REGNUM && REGNO (op) < FIRST_PSEUDO_REGISTER)
 486 +    return false;
 487 +
 488 +  return true;
 489 +})
 490 +
 491 +(define_predicate "ubicom32_fdpic_got_offset_operand"
 492 +  (match_code "unspec")
 493 +{
 494 +  if (! TARGET_FDPIC)
 495 +    return false;
 496 +
 497 +  if (GET_CODE (op) != UNSPEC)
 498 +    return false;
 499 +
 500 +  if (XINT (op, 1) != UNSPEC_FDPIC_GOT
 501 +      && XINT (op, 1) != UNSPEC_FDPIC_GOT_FUNCDESC)
 502 +    return false;
 503 +
 504 +  return true;
 505 +})
 506 +
 507 +(define_predicate "ubicom32_arith_operand"
 508 +  (match_code "subreg, reg, const_int, lo_sum, mem")
 509 +{
 510 +  return (ubicom32_move_operand (op, mode)
 511 +         && ! ubicom32_symbolic_address_operand (op, mode)
 512 +         && (! CONST_INT_P (op)
 513 +             || satisfies_constraint_I (op)));
 514 +})
 515 +
 516 +(define_predicate "ubicom32_arith_operand_dot1"
 517 +  (match_code "subreg, reg, const_int, lo_sum, mem")
 518 +{
 519 +  return (ubicom32_move_operand (op, mode)
 520 +         && ! ubicom32_symbolic_address_operand (op, mode)
 521 +         && (! CONST_INT_P (op)
 522 +             || satisfies_constraint_Q (op)));
 523 +})
 524 +
 525 +(define_predicate "ubicom32_arith_operand_dot2"
 526 +  (match_code "subreg, reg, const_int, lo_sum, mem")
 527 +{
 528 +  return (ubicom32_move_operand (op, mode)
 529 +         && ! ubicom32_symbolic_address_operand (op, mode)
 530 +         && (! CONST_INT_P (op)
 531 +             || satisfies_constraint_R (op)));
 532 +})
 533 +
 534 +(define_predicate "ubicom32_compare_operand"
 535 +  (match_code "subreg, reg, const_int, lo_sum, mem")
 536 +{
 537 + return (ubicom32_move_operand (op, mode)
 538 +         && ! ubicom32_symbolic_address_operand (op, mode)
 539 +         && (! CONST_INT_P (op)
 540 +             || satisfies_constraint_N (op)));
 541 +})
 542 +
 543 +(define_predicate "ubicom32_compare_operator"
 544 +  (match_code "compare"))
 545 +
 546 +(define_predicate "ubicom32_and_or_si3_operand"
 547 +  (match_code "subreg, reg, const_int, lo_sum, mem")
 548 +{
 549 +  return (ubicom32_arith_operand (op, mode)
 550 +         || (CONST_INT_P (op)
 551 +             && ((exact_log2 (INTVAL (op) + 1) != -1
 552 +                  && exact_log2 (INTVAL (op) + 1) <= 31)
 553 +                 || (exact_log2 (INTVAL (op)) != -1
 554 +                     && exact_log2 (INTVAL (op)) <= 31)
 555 +                 || (exact_log2 (~INTVAL (op)) != -1
 556 +                     && exact_log2 (~INTVAL (op)) <= 31))));
 557 +})
 558 +
 559 +(define_predicate "ubicom32_and_or_hi3_operand"
 560 +  (match_code "subreg, reg, const_int, lo_sum, mem")
 561 +{
 562 +  return (ubicom32_arith_operand (op, mode)
 563 +         || (CONST_INT_P (op)
 564 +             && exact_log2 (INTVAL (op) + 1) != -1
 565 +             && exact_log2 (INTVAL (op) + 1) <= 15));
 566 +})
 567 +
 568 +(define_predicate "ubicom32_mem_or_address_register_operand"
 569 +  (match_code "subreg, reg, mem")
 570 +{
 571 +  unsigned int regno;
 572 +
 573 +  if (MEM_P (op)
 574 +      && memory_operand (op, mode))
 575 +    return true;
 576 +
 577 +  if (REG_P (op))
 578 +    regno = REGNO (op);
 579 +  else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op)))
 580 +    {
 581 +      int offset;
 582 +      if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER)
 583 +       offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op)));
 584 +      else
 585 +       offset = subreg_regno_offset (REGNO (SUBREG_REG (op)),
 586 +                                     GET_MODE (SUBREG_REG (op)),
 587 +                                     SUBREG_BYTE (op),
 588 +                                     GET_MODE (op));
 589 +      regno = REGNO (SUBREG_REG (op)) + offset;
 590 +    }
 591 +  else
 592 +    return false;
 593 +
 594 +  return (regno >= FIRST_PSEUDO_REGISTER
 595 +         || REGNO_REG_CLASS (regno) == FDPIC_REG
 596 +         || REGNO_REG_CLASS (regno) == ADDRESS_REGS);
 597 +})
 598 +
 599 +(define_predicate "ubicom32_data_register_operand"
 600 +  (match_code "subreg, reg")
 601 +{
 602 +  unsigned int regno;
 603 +
 604 +  if (REG_P (op))
 605 +    regno = REGNO (op);
 606 +  else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op)))
 607 +    {
 608 +      int offset;
 609 +      if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER)
 610 +       offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op)));
 611 +      else
 612 +       offset = subreg_regno_offset (REGNO (SUBREG_REG (op)),
 613 +                                     GET_MODE (SUBREG_REG (op)),
 614 +                                     SUBREG_BYTE (op),
 615 +                                     GET_MODE (op));
 616 +      regno = REGNO (SUBREG_REG (op)) + offset;
 617 +    }
 618 +  else
 619 +    return false;
 620 +
 621 +  return ((regno >= FIRST_PSEUDO_REGISTER
 622 +          && regno != REGNO (virtual_stack_vars_rtx))
 623 +         || REGNO_REG_CLASS (regno) == DATA_REGS);
 624 +})
 625 +
 626 +(define_predicate "ubicom32_address_register_operand"
 627 +  (match_code "subreg, reg")
 628 +{
 629 +  unsigned int regno;
 630 +
 631 +  if (REG_P (op))
 632 +    regno = REGNO (op);
 633 +  else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op)))
 634 +    {
 635 +      int offset;
 636 +      if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER)
 637 +       offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op)));
 638 +      else
 639 +       offset = subreg_regno_offset (REGNO (SUBREG_REG (op)),
 640 +                                     GET_MODE (SUBREG_REG (op)),
 641 +                                     SUBREG_BYTE (op),
 642 +                                     GET_MODE (op));
 643 +      regno = REGNO (SUBREG_REG (op)) + offset;
 644 +    }
 645 +  else
 646 +    return false;
 647 +
 648 +  return (regno >= FIRST_PSEUDO_REGISTER
 649 +         || REGNO_REG_CLASS (regno) == FDPIC_REG
 650 +         || REGNO_REG_CLASS (regno) == ADDRESS_REGS);
 651 +})
 652 +
 653 +(define_predicate "ubicom32_acc_lo_register_operand"
 654 +  (match_code "subreg, reg")
 655 +{
 656 +  unsigned int regno;
 657 +
 658 +  if (REG_P (op))
 659 +    regno = REGNO (op);
 660 +  else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op)))
 661 +    {
 662 +      int offset;
 663 +      if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER)
 664 +       offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op)));
 665 +      else
 666 +       offset = subreg_regno_offset (REGNO (SUBREG_REG (op)),
 667 +                                     GET_MODE (SUBREG_REG (op)),
 668 +                                     SUBREG_BYTE (op),
 669 +                                     GET_MODE (op));
 670 +      regno = REGNO (SUBREG_REG (op)) + offset;
 671 +    }
 672 +  else
 673 +    return false;
 674 +
 675 +  return ((regno >= FIRST_PSEUDO_REGISTER
 676 +          && regno != REGNO (virtual_stack_vars_rtx))
 677 +         || REGNO_REG_CLASS (regno) == ACC_LO_REGS);
 678 +})
 679 +
 680 +(define_predicate "ubicom32_acc_hi_register_operand"
 681 +  (match_code "subreg, reg")
 682 +{
 683 +  unsigned int regno;
 684 +
 685 +  if (REG_P (op))
 686 +    regno = REGNO (op);
 687 +  else if (GET_CODE (op) == SUBREG && REG_P (SUBREG_REG (op)))
 688 +    {
 689 +      int offset;
 690 +      if (REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER)
 691 +       offset = SUBREG_BYTE (op) / (GET_MODE_SIZE (GET_MODE (op)));
 692 +      else
 693 +       offset = subreg_regno_offset (REGNO (SUBREG_REG (op)),
 694 +                                     GET_MODE (SUBREG_REG (op)),
 695 +                                     SUBREG_BYTE (op),
 696 +                                     GET_MODE (op));
 697 +      regno = REGNO (SUBREG_REG (op)) + offset;
 698 +    }
 699 +  else
 700 +    return false;
 701 +
 702 +  return ((regno >= FIRST_PSEUDO_REGISTER
 703 +          && regno != REGNO (virtual_stack_vars_rtx))
 704 +         || REGNO_REG_CLASS (regno) == ACC_REGS);
 705 +})
 706 +
 707 +(define_predicate "ubicom32_call_address_operand"
 708 +  (match_code "symbol_ref, subreg, reg")
 709 +{
 710 +  return (GET_CODE (op) == SYMBOL_REF || REG_P (op));
 711 +})
 712 +
 713 +(define_special_predicate "ubicom32_cc_register_operand"
 714 +  (and (match_code "reg")
 715 +       (match_test "REGNO (op) == CC_REGNUM")))
 716 +
 717 --- /dev/null
 718 +++ b/gcc/config/ubicom32/t-ubicom32
 719 @@ -0,0 +1,52 @@
 720 +# Name of assembly file containing libgcc1 functions.
 721 +# This entry must be present, but it can be empty if the target does
 722 +# not need any assembler functions to support its code generation.
 723 +CROSS_LIBGCC1 =
 724 +
 725 +# Alternatively if assembler functions *are* needed then define the
 726 +# entries below:
 727 +# CROSS_LIBGCC1 = libgcc1-asm.a
 728 +
 729 +LIB2FUNCS_EXTRA = \
 730 +       $(srcdir)/config/udivmodsi4.c \
 731 +       $(srcdir)/config/divmod.c \
 732 +       $(srcdir)/config/udivmod.c
 733 +
 734 +# If any special flags are necessary when building libgcc2 put them here.
 735 +#
 736 +# TARGET_LIBGCC2_CFLAGS =
 737 +
 738 +# We want fine grained libraries, so use the new code to build the
 739 +# floating point emulation libraries.
 740 +FPBIT = fp-bit.c
 741 +DPBIT = dp-bit.c
 742 +
 743 +fp-bit.c: $(srcdir)/config/fp-bit.c
 744 +       echo '#define FLOAT'                            > fp-bit.c
 745 +       cat $(srcdir)/config/fp-bit.c                   >> fp-bit.c
 746 +
 747 +dp-bit.c: $(srcdir)/config/fp-bit.c
 748 +       cat $(srcdir)/config/fp-bit.c > dp-bit.c
 749 +
 750 +# Commented out to speed up compiler development!
 751 +#
 752 +# MULTILIB_OPTIONS = march=ubicom32v1/march=ubicom32v2/march=ubicom32v3/march=ubicom32v4
 753 +# MULTILIB_DIRNAMES = ubicom32v1 ubicom32v2 ubicom32v3 ubicom32v4
 754 +
 755 +MULTILIB_OPTIONS = march=ubicom32v3/march=ubicom32v4
 756 +MULTILIB_OPTIONS += mfdpic
 757 +MULTILIB_OPTIONS += mno-ipos-abi/mipos-abi
 758 +MULTILIB_OPTIONS += fno-leading-underscore/fleading-underscore
 759 +
 760 +# Assemble startup files.
 761 +$(T)crti.o: $(srcdir)/config/ubicom32/crti.S $(GCC_PASSES)
 762 +       $(GCC_FOR_TARGET) $(GCC_CFLAGS) $(MULTILIB_CFLAGS) $(INCLUDES) \
 763 +       -c -o $(T)crti.o -x assembler-with-cpp $(srcdir)/config/ubicom32/crti.S
 764 +
 765 +$(T)crtn.o: $(srcdir)/config/ubicom32/crtn.S $(GCC_PASSES)
 766 +       $(GCC_FOR_TARGET) $(GCC_CFLAGS) $(MULTILIB_CFLAGS) $(INCLUDES) \
 767 +       -c -o $(T)crtn.o -x assembler-with-cpp $(srcdir)/config/ubicom32/crtn.S
 768 +
 769 +# these parts are required because uClibc ldso needs them to link.
 770 +# they are not in the specfile so they will not be included automatically.
 771 +EXTRA_MULTILIB_PARTS = crtbegin.o crtend.o crtbeginS.o crtendS.o crti.o crtn.o
 772 --- /dev/null
 773 +++ b/gcc/config/ubicom32/t-ubicom32-linux
 774 @@ -0,0 +1,35 @@
 775 +# Name of assembly file containing libgcc1 functions.
 776 +# This entry must be present, but it can be empty if the target does
 777 +# not need any assembler functions to support its code generation.
 778 +CROSS_LIBGCC1 =
 779 +
 780 +# Alternatively if assembler functions *are* needed then define the
 781 +# entries below:
 782 +# CROSS_LIBGCC1 = libgcc1-asm.a
 783 +
 784 +LIB2FUNCS_EXTRA = \
 785 +       $(srcdir)/config/udivmodsi4.c \
 786 +       $(srcdir)/config/divmod.c \
 787 +       $(srcdir)/config/udivmod.c
 788 +
 789 +# If any special flags are necessary when building libgcc2 put them here.
 790 +#
 791 +# TARGET_LIBGCC2_CFLAGS =
 792 +
 793 +# We want fine grained libraries, so use the new code to build the
 794 +# floating point emulation libraries.
 795 +FPBIT = fp-bit.c
 796 +DPBIT = dp-bit.c
 797 +
 798 +fp-bit.c: $(srcdir)/config/fp-bit.c
 799 +       echo '#define FLOAT'                            > fp-bit.c
 800 +       cat $(srcdir)/config/fp-bit.c                   >> fp-bit.c
 801 +
 802 +dp-bit.c: $(srcdir)/config/fp-bit.c
 803 +       cat $(srcdir)/config/fp-bit.c > dp-bit.c
 804 +
 805 +# We only support v3 and v4 ISAs for uClinux.
 806 +
 807 +MULTILIB_OPTIONS = march=ubicom32v3/march=ubicom32v4
 808 +
 809 +#EXTRA_MULTILIB_PARTS = crtbegin.o crtend.o crtbeginS.o crtendS.o
 810 --- /dev/null
 811 +++ b/gcc/config/ubicom32/t-ubicom32-uclinux
 812 @@ -0,0 +1,35 @@
 813 +# Name of assembly file containing libgcc1 functions.
 814 +# This entry must be present, but it can be empty if the target does
 815 +# not need any assembler functions to support its code generation.
 816 +CROSS_LIBGCC1 =
 817 +
 818 +# Alternatively if assembler functions *are* needed then define the
 819 +# entries below:
 820 +# CROSS_LIBGCC1 = libgcc1-asm.a
 821 +
 822 +LIB2FUNCS_EXTRA = \
 823 +       $(srcdir)/config/udivmodsi4.c \
 824 +       $(srcdir)/config/divmod.c \
 825 +       $(srcdir)/config/udivmod.c
 826 +
 827 +# If any special flags are necessary when building libgcc2 put them here.
 828 +#
 829 +# TARGET_LIBGCC2_CFLAGS =
 830 +
 831 +# We want fine grained libraries, so use the new code to build the
 832 +# floating point emulation libraries.
 833 +FPBIT = fp-bit.c
 834 +DPBIT = dp-bit.c
 835 +
 836 +fp-bit.c: $(srcdir)/config/fp-bit.c
 837 +       echo '#define FLOAT'                            > fp-bit.c
 838 +       cat $(srcdir)/config/fp-bit.c                   >> fp-bit.c
 839 +
 840 +dp-bit.c: $(srcdir)/config/fp-bit.c
 841 +       cat $(srcdir)/config/fp-bit.c > dp-bit.c
 842 +
 843 +# We only support v3 and v4 ISAs for uClinux.
 844 +
 845 +MULTILIB_OPTIONS = march=ubicom32v3/march=ubicom32v4
 846 +
 847 +EXTRA_MULTILIB_PARTS = crtbegin.o crtend.o # crtbeginS.o crtendS.o
 848 --- /dev/null
 849 +++ b/gcc/config/ubicom32/ubicom32-modes.def
 850 @@ -0,0 +1,30 @@
 851 +/* Definitions of target machine for GNU compiler, Ubicom32 architecture.
 852 +   Copyright (C) 2009 Free Software Foundation, Inc.
 853 +   Contributed by Ubicom, Inc.
 854 +
 855 +   This file is part of GCC.
 856 +
 857 +   GCC is free software; you can redistribute it and/or modify it
 858 +   under the terms of the GNU General Public License as published
 859 +   by the Free Software Foundation; either version 3, or (at your
 860 +   option) any later version.
 861 +
 862 +   GCC is distributed in the hope that it will be useful, but WITHOUT
 863 +   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 864 +   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 865 +   License for more details.
 866 +
 867 +   You should have received a copy of the GNU General Public License
 868 +   along with GCC; see the file COPYING3.  If not see
 869 +   <http://www.gnu.org/licenses/>.  */
 870 +
 871 +/* Some insns set all condition code flags, some only set the Z and N flags, and
 872 +   some only set the Z flag.  */
 873 +
 874 +CC_MODE (CCW);
 875 +CC_MODE (CCWZN);
 876 +CC_MODE (CCWZ);
 877 +CC_MODE (CCS);
 878 +CC_MODE (CCSZN);
 879 +CC_MODE (CCSZ);
 880 +
 881 --- /dev/null
 882 +++ b/gcc/config/ubicom32/ubicom32-protos.h
 883 @@ -0,0 +1,84 @@
 884 +/* Function prototypes for Ubicom IP3000.
 885 +
 886 +   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
 887 +   2009 Free Software Foundation, Inc.
 888 +   Contributed by Ubicom, Inc.
 889 +
 890 +   This file is part of GNU CC.
 891 +
 892 +   GNU CC is free software; you can redistribute it and/or modify it under
 893 +   the terms of the GNU General Public License as published by the Free
 894 +   Software Foundation; either version 2, or (at your option) any later
 895 +   version.
 896 +
 897 +   GNU CC is distributed in the hope that it will be useful, but WITHOUT
 898 +   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 899 +   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 900 +   for more details.
 901 +
 902 +   You should have received a copy of the GNU General Public License along
 903 +   with GNU CC; see the file COPYING.  If not, write to the Free Software
 904 +   Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 905 +
 906 +#ifdef RTX_CODE
 907 +
 908 +#ifdef TREE_CODE
 909 +extern void ubicom32_va_start (tree, rtx);
 910 +#endif /* TREE_CODE */
 911 +
 912 +extern void ubicom32_print_operand (FILE *, rtx, int);
 913 +extern void ubicom32_print_operand_address (FILE *, rtx);
 914 +
 915 +extern void ubicom32_conditional_register_usage (void);
 916 +extern enum reg_class ubicom32_preferred_reload_class (rtx, enum reg_class);
 917 +extern int ubicom32_regno_ok_for_index_p (int, int);
 918 +extern void ubicom32_expand_movsi (rtx *);
 919 +extern void ubicom32_expand_addsi3 (rtx *);
 920 +extern int ubicom32_emit_mult_sequence (rtx *);
 921 +extern void ubicom32_emit_move_const_int (rtx, rtx);
 922 +extern bool ubicom32_legitimate_constant_p (rtx);
 923 +extern bool ubicom32_legitimate_address_p (enum machine_mode, rtx, int);
 924 +extern rtx ubicom32_legitimize_address (rtx, rtx, enum machine_mode);
 925 +extern rtx ubicom32_legitimize_reload_address (rtx, enum machine_mode, int, int);
 926 +extern void ubicom32_canonicalize_comparison (enum rtx_code *code, rtx *op0, rtx *op1);
 927 +extern int ubicom32_mode_dependent_address_p (rtx);
 928 +extern void ubicom32_output_cond_jump (rtx, rtx, rtx);
 929 +extern void ubicom32_expand_eh_return (rtx *);
 930 +extern void ubicom32_expand_call_fdpic (rtx *);
 931 +extern void ubicom32_expand_call_value_fdpic (rtx *);
 932 +extern enum machine_mode ubicom32_select_cc_mode (RTX_CODE, rtx, rtx);
 933 +extern rtx ubicom32_gen_compare_reg (RTX_CODE, rtx, rtx);
 934 +extern int ubicom32_shiftable_const_int (int);
 935 +#endif /* RTX_CODE */
 936 +
 937 +#ifdef TREE_CODE
 938 +extern void init_cumulative_args (CUMULATIVE_ARGS *cum,
 939 +                                 tree fntype,
 940 +                                 struct rtx_def *libname,
 941 +                                 int indirect);
 942 +extern struct rtx_def *function_arg (CUMULATIVE_ARGS *,
 943 +                                    enum machine_mode, tree, int);
 944 +extern struct rtx_def *function_incoming_arg (CUMULATIVE_ARGS *,
 945 +                                             enum machine_mode,
 946 +                                             tree, int);
 947 +extern int function_arg_partial_nregs (CUMULATIVE_ARGS *,
 948 +                                      enum machine_mode, tree, int);
 949 +extern struct rtx_def *ubicom32_va_arg (tree, tree);
 950 +extern int ubicom32_reg_parm_stack_space (tree);
 951 +#endif /* TREE_CODE */
 952 +
 953 +extern struct rtx_def * ubicom32_builtin_saveregs (void);
 954 +extern void asm_file_start (FILE *);
 955 +extern void ubicom32_expand_prologue (void);
 956 +extern void ubicom32_expand_epilogue (void);
 957 +extern int ubicom32_initial_elimination_offset (int, int);
 958 +extern int ubicom32_regno_ok_for_base_p (int, int);
 959 +extern bool ubicom32_hard_regno_mode_ok (unsigned int, enum machine_mode);
 960 +extern int ubicom32_can_use_return_insn_p (void);
 961 +extern rtx ubicom32_return_addr_rtx (int, rtx);
 962 +extern void ubicom32_optimization_options (int, int);
 963 +extern void ubicom32_override_options (void);
 964 +extern bool ubicom32_match_cc_mode (rtx, enum machine_mode);
 965 +
 966 +extern int ubicom32_reorg_completed;
 967 +
 968 --- /dev/null
 969 +++ b/gcc/config/ubicom32/ubicom32.c
 970 @@ -0,0 +1,2881 @@
 971 +/* Subroutines for insn-output.c for Ubicom32
 972 +
 973 +   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
 974 +   2009 Free Software Foundation, Inc.
 975 +   Contributed by Ubicom, Inc.
 976 +
 977 +   This file is part of GCC.
 978 +
 979 +   GCC is free software; you can redistribute it and/or modify it
 980 +   under the terms of the GNU General Public License as published
 981 +   by the Free Software Foundation; either version 3, or (at your
 982 +   option) any later version.
 983 +
 984 +   GCC is distributed in the hope that it will be useful, but WITHOUT
 985 +   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 986 +   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 987 +   License for more details.
 988 +
 989 +   You should have received a copy of the GNU General Public License
 990 +   along with GCC; see the file COPYING3.  If not see
 991 +   <http://www.gnu.org/licenses/>.  */
 992 +
 993 +#include "config.h"
 994 +#include "system.h"
 995 +#include "coretypes.h"
 996 +#include "tm.h"
 997 +#include "rtl.h"
 998 +#include "tree.h"
 999 +#include "regs.h"
1000 +#include "hard-reg-set.h"
1001 +#include "real.h"
1002 +#include "insn-config.h"
1003 +#include "conditions.h"
1004 +#include "insn-flags.h"
1005 +#include "output.h"
1006 +#include "insn-attr.h"
1007 +#include "insn-codes.h"
1008 +#include "flags.h"
1009 +#include "recog.h"
1010 +#include "expr.h"
1011 +#include "function.h"
1012 +#include "obstack.h"
1013 +#include "toplev.h"
1014 +#include "tm_p.h"
1015 +#include "tm-constrs.h"
1016 +#include "basic-block.h"
1017 +#include "integrate.h"
1018 +#include "target.h"
1019 +#include "target-def.h"
1020 +#include "reload.h"
1021 +#include "df.h"
1022 +#include "langhooks.h"
1023 +#include "optabs.h"
1024 +
1025 +static tree ubicom32_handle_fndecl_attribute (tree *, tree, tree, int, bool *);
1026 +static void ubicom32_layout_frame (void);
1027 +static void ubicom32_function_prologue (FILE *, HOST_WIDE_INT);
1028 +static void ubicom32_function_epilogue (FILE *, HOST_WIDE_INT);
1029 +static bool ubicom32_rtx_costs (rtx, int, int, int *, bool speed);
1030 +static bool ubicom32_fixed_condition_code_regs (unsigned int *,
1031 +                                               unsigned int *);
1032 +static enum machine_mode ubicom32_cc_modes_compatible (enum machine_mode,
1033 +                                                      enum machine_mode);
1034 +static int ubicom32_naked_function_p (void);
1035 +static void ubicom32_machine_dependent_reorg (void);
1036 +static bool ubicom32_assemble_integer (rtx, unsigned int, int);
1037 +static void ubicom32_asm_init_sections (void);
1038 +static int ubicom32_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,tree,
1039 +                                      bool);
1040 +static bool ubicom32_pass_by_reference (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
1041 +                                       enum machine_mode mode, const_tree type,
1042 +                                       bool named ATTRIBUTE_UNUSED);
1043 +static bool ubicom32_callee_copies (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
1044 +                                   enum machine_mode mode, const_tree type,
1045 +                                   bool named ATTRIBUTE_UNUSED);
1046 +
1047 +static bool ubicom32_return_in_memory (const_tree type,
1048 +                                      const_tree fntype ATTRIBUTE_UNUSED);
1049 +static bool ubicom32_is_base_reg (rtx, int);
1050 +static void ubicom32_init_builtins (void);
1051 +static rtx ubicom32_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
1052 +static tree ubicom32_fold_builtin (tree, tree, bool);
1053 +static int ubicom32_get_valid_offset_mask (enum machine_mode);
1054 +static bool ubicom32_cannot_force_const_mem (rtx);
1055 +
1056 +/* Case values threshold */
1057 +int ubicom32_case_values_threshold = 6;
1058 +
1059 +/* Nonzero if this chip supports the Ubicom32 v3 ISA.  */
1060 +int ubicom32_v3 = 1;
1061 +
1062 +/* Nonzero if this chip supports the Ubicom32 v4 ISA.  */
1063 +int ubicom32_v4 = 1;
1064 +
1065 +/* Valid attributes:
1066 +   naked - don't generate function prologue/epilogue and `ret' command.  */
1067 +const struct attribute_spec ubicom32_attribute_table[] =
1068 +{
1069 +  /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1070 +  { "naked", 0, 0, true,  false, false, ubicom32_handle_fndecl_attribute },
1071 +  { NULL,    0, 0, false, false, false, NULL }
1072 +};
1073 +
1074 +#undef TARGET_ASM_FUNCTION_PROLOGUE
1075 +#define TARGET_ASM_FUNCTION_PROLOGUE ubicom32_function_prologue
1076 +
1077 +#undef TARGET_ASM_FUNCTION_EPILOGUE
1078 +#define TARGET_ASM_FUNCTION_EPILOGUE ubicom32_function_epilogue
1079 +
1080 +#undef TARGET_ATTRIBUTE_TABLE
1081 +#define TARGET_ATTRIBUTE_TABLE ubicom32_attribute_table
1082 +
1083 +/* All addresses cost the same amount.  */
1084 +#undef TARGET_ADDRESS_COST
1085 +#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
1086 +
1087 +#undef TARGET_RTX_COSTS
1088 +#define TARGET_RTX_COSTS ubicom32_rtx_costs
1089 +
1090 +#undef TARGET_FIXED_CONDITION_CODE_REGS
1091 +#define TARGET_FIXED_CONDITION_CODE_REGS ubicom32_fixed_condition_code_regs
1092 +
1093 +#undef TARGET_CC_MODES_COMPATIBLE
1094 +#define TARGET_CC_MODES_COMPATIBLE ubicom32_cc_modes_compatible
1095 +
1096 +#undef TARGET_MACHINE_DEPENDENT_REORG
1097 +#define TARGET_MACHINE_DEPENDENT_REORG ubicom32_machine_dependent_reorg
1098 +
1099 +#undef  TARGET_ASM_INTEGER
1100 +#define TARGET_ASM_INTEGER ubicom32_assemble_integer
1101 +
1102 +#undef TARGET_ASM_INIT_SECTIONS
1103 +#define TARGET_ASM_INIT_SECTIONS ubicom32_asm_init_sections
1104 +
1105 +#undef TARGET_ARG_PARTIAL_BYTES
1106 +#define TARGET_ARG_PARTIAL_BYTES ubicom32_arg_partial_bytes
1107 +
1108 +#undef TARGET_PASS_BY_REFERENCE
1109 +#define TARGET_PASS_BY_REFERENCE ubicom32_pass_by_reference
1110 +
1111 +#undef TARGET_CALLEE_COPIES
1112 +#define TARGET_CALLEE_COPIES ubicom32_callee_copies
1113 +
1114 +#undef TARGET_RETURN_IN_MEMORY
1115 +#define TARGET_RETURN_IN_MEMORY ubicom32_return_in_memory
1116 +
1117 +#undef TARGET_INIT_BUILTINS
1118 +#define TARGET_INIT_BUILTINS ubicom32_init_builtins
1119 +
1120 +#undef TARGET_EXPAND_BUILTIN
1121 +#define TARGET_EXPAND_BUILTIN ubicom32_expand_builtin
1122 +
1123 +#undef TARGET_FOLD_BUILTIN
1124 +#define TARGET_FOLD_BUILTIN ubicom32_fold_builtin
1125 +
1126 +#undef TARGET_CANNOT_FORCE_CONST_MEM
1127 +#define TARGET_CANNOT_FORCE_CONST_MEM ubicom32_cannot_force_const_mem
1128 +
1129 +struct gcc_target targetm = TARGET_INITIALIZER;
1130 +
1131 +static char save_regs[FIRST_PSEUDO_REGISTER];
1132 +static int nregs;
1133 +static int frame_size;
1134 +int ubicom32_stack_size = 0;   /* size of allocated stack (including frame) */
1135 +int ubicom32_can_use_calli_to_ret;
1136 +
1137 +#define STACK_UNIT_BOUNDARY (STACK_BOUNDARY / BITS_PER_UNIT)
1138 +#define ROUND_CALL_BLOCK_SIZE(BYTES) \
1139 +  (((BYTES) + (STACK_UNIT_BOUNDARY - 1)) & ~(STACK_UNIT_BOUNDARY - 1))
1140 +
1141 +/* In case of a PRE_INC, POST_INC, PRE_DEC, POST_DEC memory reference, we
1142 +   must report the mode of the memory reference from PRINT_OPERAND to
1143 +   PRINT_OPERAND_ADDRESS.  */
1144 +enum machine_mode output_memory_reference_mode;
1145 +
1146 +/* Flag for some split insns from the ubicom32.md.  */
1147 +int ubicom32_reorg_completed;
1148 +
1149 +enum reg_class const ubicom32_regclass_map[FIRST_PSEUDO_REGISTER] =
1150 +{
1151 +  DATA_REGS,
1152 +  DATA_REGS,
1153 +  DATA_REGS,
1154 +  DATA_REGS,
1155 +  DATA_REGS,
1156 +  DATA_REGS,
1157 +  DATA_REGS,
1158 +  DATA_REGS,
1159 +  DATA_REGS,
1160 +  DATA_REGS,
1161 +  DATA_REGS,
1162 +  DATA_REGS,
1163 +  DATA_REGS,
1164 +  DATA_REGS,
1165 +  DATA_REGS,
1166 +  DATA_REGS,
1167 +  FDPIC_REG,
1168 +  ADDRESS_REGS,
1169 +  ADDRESS_REGS,
1170 +  ADDRESS_REGS,
1171 +  ADDRESS_REGS,
1172 +  ADDRESS_REGS,
1173 +  ADDRESS_REGS,
1174 +  ADDRESS_REGS,
1175 +  ACC_REGS,
1176 +  ACC_LO_REGS,
1177 +  ACC_REGS,
1178 +  ACC_LO_REGS,
1179 +  SOURCE3_REG,
1180 +  ADDRESS_REGS,
1181 +  NO_REGS,                     /* CC_REG must be NO_REGS */
1182 +  SPECIAL_REGS,
1183 +  SPECIAL_REGS,
1184 +  SPECIAL_REGS,
1185 +  SPECIAL_REGS,
1186 +  SPECIAL_REGS,
1187 +  SPECIAL_REGS,
1188 +  SPECIAL_REGS,
1189 +  SPECIAL_REGS
1190 +};
1191 +
1192 +rtx ubicom32_compare_op0;
1193 +rtx ubicom32_compare_op1;
1194 +
1195 +/* Handle command line option overrides.  */
1196 +
1197 +void
1198 +ubicom32_override_options (void)
1199 +{
1200 +  flag_pic = 0;
1201 +
1202 +  if (strcmp (ubicom32_arch_name, "ubicom32v1") == 0) {
1203 +    /* If we have a version 1 architecture then we want to avoid using jump
1204 +       tables.  */
1205 +    ubicom32_case_values_threshold = 30000;
1206 +    ubicom32_v3 = 0;
1207 +    ubicom32_v4 = 0;
1208 +  } else if (strcmp (ubicom32_arch_name, "ubicom32v2") == 0) {
1209 +    ubicom32_v3 = 0;
1210 +    ubicom32_v4 = 0;
1211 +  } else if (strcmp (ubicom32_arch_name, "ubicom32v3") == 0) {
1212 +    ubicom32_v3 = 1;
1213 +    ubicom32_v4 = 0;
1214 +  } else if (strcmp (ubicom32_arch_name, "ubicom32v4") == 0) {
1215 +    ubicom32_v3 = 1;
1216 +    ubicom32_v4 = 1;
1217 +  }
1218 +
1219 +  /* There is no single unaligned SI op for PIC code.  Sometimes we
1220 +     need to use ".4byte" and sometimes we need to use ".picptr".
1221 +     See ubicom32_assemble_integer for details.  */
1222 +  if (TARGET_FDPIC)
1223 +    targetm.asm_out.unaligned_op.si = 0;
1224 +}
1225 +
1226 +void
1227 +ubicom32_conditional_register_usage (void)
1228 +{
1229 +  /* If we're using the old ipOS ABI we need to make D10 through D13
1230 +     caller-clobbered.  */
1231 +  if (TARGET_IPOS_ABI)
1232 +    {
1233 +      call_used_regs[D10_REGNUM] = 1;
1234 +      call_used_regs[D11_REGNUM] = 1;
1235 +      call_used_regs[D12_REGNUM] = 1;
1236 +      call_used_regs[D13_REGNUM] = 1;
1237 +    }
1238 +}
1239 +
1240 +/* We have some number of optimizations that don't really work for the Ubicom32
1241 +   architecture so we deal with them here.  */
1242 +
1243 +void
1244 +ubicom32_optimization_options (int level ATTRIBUTE_UNUSED,
1245 +                              int size ATTRIBUTE_UNUSED)
1246 +{
1247 +  /* The tree IVOPTs pass seems to do really bad things for the Ubicom32
1248 +     architecture - it tends to turn things that would happily use pre/post
1249 +     increment/decrement into operations involving unecessary loop
1250 +     indicies.  */
1251 +  flag_ivopts = 0;
1252 +
1253 +  /* We have problems where DSE at the RTL level misses partial stores
1254 +     to the stack.  For now we disable it to avoid this.  */
1255 +  flag_dse = 0;
1256 +}
1257 +
1258 +/* Print operand X using operand code CODE to assembly language output file
1259 +   FILE.  */
1260 +
1261 +void
1262 +ubicom32_print_operand (FILE *file, rtx x, int code)
1263 +{
1264 +  switch (code)
1265 +    {
1266 +    case 'A':
1267 +      /* Identify the correct accumulator to use.  */
1268 +      if (REGNO (x) == ACC0_HI_REGNUM || REGNO (x) == ACC0_LO_REGNUM)
1269 +       fprintf (file, "acc0");
1270 +      else if (REGNO (x) == ACC1_HI_REGNUM || REGNO (x) == ACC1_LO_REGNUM)
1271 +       fprintf (file, "acc1");
1272 +      else
1273 +       abort ();
1274 +      break;
1275 +
1276 +    case 'b':
1277 +    case 'B':
1278 +      {
1279 +       enum machine_mode mode;
1280 +
1281 +       mode = GET_MODE (XEXP (x, 0));
1282 +
1283 +       /* These are normal and reversed branches.  */
1284 +       switch (code == 'b' ? GET_CODE (x) : reverse_condition (GET_CODE (x)))
1285 +         {
1286 +         case NE:
1287 +           fprintf (file, "ne");
1288 +           break;
1289 +
1290 +         case EQ:
1291 +           fprintf (file, "eq");
1292 +           break;
1293 +
1294 +         case GE:
1295 +           if (mode == CCSZNmode || mode == CCWZNmode)
1296 +             fprintf (file, "pl");
1297 +           else
1298 +             fprintf (file, "ge");
1299 +           break;
1300 +
1301 +         case GT:
1302 +           fprintf (file, "gt");
1303 +           break;
1304 +
1305 +         case LE:
1306 +           fprintf (file, "le");
1307 +           break;
1308 +
1309 +         case LT:
1310 +           if (mode == CCSZNmode || mode == CCWZNmode)
1311 +             fprintf (file, "mi");
1312 +           else
1313 +             fprintf (file, "lt");
1314 +           break;
1315 +
1316 +         case GEU:
1317 +           fprintf (file, "cs");
1318 +           break;
1319 +
1320 +         case GTU:
1321 +           fprintf (file, "hi");
1322 +           break;
1323 +
1324 +         case LEU:
1325 +           fprintf (file, "ls");
1326 +           break;
1327 +
1328 +         case LTU:
1329 +           fprintf (file, "cc");
1330 +           break;
1331 +
1332 +         default:
1333 +           abort ();
1334 +         }
1335 +      }
1336 +      break;
1337 +
1338 +    case 'C':
1339 +      /* This is used for the operand to a call instruction;
1340 +        if it's a REG, enclose it in parens, else output
1341 +        the operand normally.  */
1342 +      if (REG_P (x))
1343 +       {
1344 +         fputc ('(', file);
1345 +         ubicom32_print_operand (file, x, 0);
1346 +         fputc (')', file);
1347 +       }
1348 +      else
1349 +       ubicom32_print_operand (file, x, 0);
1350 +      break;
1351 +
1352 +    case 'd':
1353 +      /* Bit operations we need bit numbers. */
1354 +      fprintf (file, "%d", exact_log2 (INTVAL (x)));
1355 +      break;
1356 +
1357 +    case 'D':
1358 +      /* Bit operations we need bit numbers. */
1359 +      fprintf (file, "%d", exact_log2 (~ INTVAL (x)));
1360 +      break;
1361 +
1362 +    case 'E':
1363 +      /* For lea, which we use to add address registers.
1364 +        We don't want the '#' on a constant. */
1365 +      if (CONST_INT_P (x))
1366 +       {
1367 +         fprintf (file, "%ld", INTVAL (x));
1368 +         break;
1369 +       }
1370 +      /* FALL THROUGH */
1371 +
1372 +    default:
1373 +      switch (GET_CODE (x))
1374 +       {
1375 +       case MEM:
1376 +         output_memory_reference_mode = GET_MODE (x);
1377 +         output_address (XEXP (x, 0));
1378 +         break;
1379 +
1380 +       case PLUS:
1381 +         output_address (x);
1382 +         break;
1383 +
1384 +       case REG:
1385 +         fprintf (file, "%s", reg_names[REGNO (x)]);
1386 +         break;
1387 +
1388 +       case SUBREG:
1389 +         fprintf (file, "%s", reg_names[subreg_regno (x)]);
1390 +         break;
1391 +
1392 +       /* This will only be single precision....  */
1393 +       case CONST_DOUBLE:
1394 +         {
1395 +           unsigned long val;
1396 +           REAL_VALUE_TYPE rv;
1397 +
1398 +           REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
1399 +           REAL_VALUE_TO_TARGET_SINGLE (rv, val);
1400 +           fprintf (file, "0x%lx", val);
1401 +           break;
1402 +         }
1403 +
1404 +       case CONST_INT:
1405 +       case SYMBOL_REF:
1406 +       case CONST:
1407 +       case LABEL_REF:
1408 +       case CODE_LABEL:
1409 +       case LO_SUM:
1410 +         ubicom32_print_operand_address (file, x);
1411 +         break;
1412 +
1413 +       case HIGH:
1414 +         fprintf (file, "#%%hi(");
1415 +         ubicom32_print_operand_address (file, XEXP (x, 0));
1416 +         fprintf (file, ")");
1417 +         break;
1418 +
1419 +       case UNSPEC:
1420 +         switch (XINT (x, 1))
1421 +           {
1422 +           case UNSPEC_FDPIC_GOT:
1423 +             fprintf (file, "#%%got_lo(");
1424 +             ubicom32_print_operand_address (file, XVECEXP (x, 0, 0));
1425 +             fprintf (file, ")");
1426 +             break;
1427 +
1428 +           case UNSPEC_FDPIC_GOT_FUNCDESC:
1429 +             fprintf (file, "#%%got_funcdesc_lo(");
1430 +             ubicom32_print_operand_address (file, XVECEXP (x, 0, 0));
1431 +             fprintf (file, ")");
1432 +             break;
1433 +
1434 +           default:
1435 +             abort ();
1436 +           }
1437 +          break;
1438 +
1439 +       default:
1440 +         abort ();
1441 +       }
1442 +      break;
1443 +   }
1444 +}
1445 +
1446 +/* Output assembly language output for the address ADDR to FILE.  */
1447 +
1448 +void
1449 +ubicom32_print_operand_address (FILE *file, rtx addr)
1450 +{
1451 +  switch (GET_CODE (addr))
1452 +    {
1453 +    case POST_INC:
1454 +      ubicom32_print_operand_address (file, XEXP (addr, 0));
1455 +      fprintf (file, "%d++", GET_MODE_SIZE (output_memory_reference_mode));
1456 +      break;
1457 +
1458 +    case PRE_INC:
1459 +      fprintf (file, "%d", GET_MODE_SIZE (output_memory_reference_mode));
1460 +      ubicom32_print_operand_address (file, XEXP (addr, 0));
1461 +      fprintf (file, "++");
1462 +      break;
1463 +
1464 +    case POST_DEC:
1465 +      ubicom32_print_operand_address (file, XEXP (addr, 0));
1466 +      fprintf (file, "%d++", -GET_MODE_SIZE (output_memory_reference_mode));
1467 +      break;
1468 +
1469 +    case PRE_DEC:
1470 +      fprintf (file, "%d", -GET_MODE_SIZE (output_memory_reference_mode));
1471 +      ubicom32_print_operand_address (file, XEXP (addr, 0));
1472 +      fprintf (file, "++");
1473 +      break;
1474 +
1475 +    case POST_MODIFY:
1476 +      ubicom32_print_operand_address (file, XEXP (addr, 0));
1477 +      fprintf (file, "%ld++", INTVAL (XEXP (XEXP (addr,1), 1)));
1478 +      break;
1479 +
1480 +    case PRE_MODIFY:
1481 +      fprintf (file, "%ld", INTVAL (XEXP (XEXP (addr,1), 1)));
1482 +      ubicom32_print_operand_address (file, XEXP (addr, 0));
1483 +      fprintf (file, "++");
1484 +      break;
1485 +
1486 +    case REG:
1487 +      fputc ('(', file);
1488 +      fprintf (file, "%s", reg_names[REGNO (addr)]);
1489 +      fputc (')', file);
1490 +      break;
1491 +
1492 +    case PLUS:
1493 +      {
1494 +       rtx base = XEXP (addr, 0);
1495 +       rtx index = XEXP (addr, 1);
1496 +
1497 +       /* Switch around addresses of the form index * scaling + base.  */
1498 +       if (! ubicom32_is_base_reg (base, 1))
1499 +         {
1500 +           rtx tmp = base;
1501 +           base = index;
1502 +           index = tmp;
1503 +         }
1504 +
1505 +       if (CONST_INT_P (index))
1506 +         {
1507 +           fprintf (file, "%ld", INTVAL (index));
1508 +           fputc ('(', file);
1509 +           fputs (reg_names[REGNO (base)], file);
1510 +         }
1511 +       else if (GET_CODE (index) == MULT
1512 +                || REG_P (index))
1513 +         {
1514 +           if (GET_CODE (index) == MULT)
1515 +             index = XEXP (index, 0);
1516 +           fputc ('(', file);
1517 +           fputs (reg_names[REGNO (base)], file);
1518 +           fputc (',', file);
1519 +           fputs (reg_names[REGNO (index)], file);
1520 +         }
1521 +       else
1522 +         abort ();
1523 +
1524 +       fputc (')', file);
1525 +       break;
1526 +      }
1527 +
1528 +    case LO_SUM:
1529 +      fprintf (file, "%%lo(");
1530 +      ubicom32_print_operand (file, XEXP (addr, 1), 'L');
1531 +      fprintf (file, ")(");
1532 +      ubicom32_print_operand (file, XEXP (addr, 0), 0);
1533 +      fprintf (file, ")");
1534 +      break;
1535 +
1536 +    case CONST_INT:
1537 +      fputc ('#', file);
1538 +      output_addr_const (file, addr);
1539 +      break;
1540 +
1541 +    default:
1542 +      output_addr_const (file, addr);
1543 +      break;
1544 +    }
1545 +}
1546 +
1547 +/* X and Y are two things to compare using CODE.  Emit the compare insn and
1548 +   return the rtx for the cc reg in the proper mode.  */
1549 +
1550 +rtx
1551 +ubicom32_gen_compare_reg (enum rtx_code code, rtx x, rtx y)
1552 +{
1553 +  enum machine_mode mode = SELECT_CC_MODE (code, x, y);
1554 +  rtx cc_reg;
1555 +
1556 +  cc_reg = gen_rtx_REG (mode, CC_REGNUM);
1557 +
1558 +  emit_insn (gen_rtx_SET (VOIDmode, cc_reg,
1559 +                         gen_rtx_COMPARE (mode, x, y)));
1560 +
1561 +  return cc_reg;
1562 +}
1563 +
1564 +/* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
1565 +   return the mode to be used for the comparison.  */
1566 +
1567 +enum machine_mode
1568 +ubicom32_select_cc_mode (enum rtx_code op, rtx x, rtx y)
1569 +{
1570 +  /* Is this a short compare?  */
1571 +  if (GET_MODE (x) == QImode
1572 +      || GET_MODE (x) == HImode
1573 +      || GET_MODE (y) == QImode
1574 +      || GET_MODE (y) == HImode)
1575 +    {
1576 +      switch (op)
1577 +       {
1578 +       case EQ :
1579 +       case NE :
1580 +         return CCSZmode;
1581 +
1582 +       case GE:
1583 +       case LT:
1584 +         if (y == const0_rtx)
1585 +           return CCSZNmode;
1586 +
1587 +       default :
1588 +         return CCSmode;
1589 +       }
1590 +    }
1591 +
1592 +  /* We have a word compare.  */
1593 +  switch (op)
1594 +    {
1595 +    case EQ :
1596 +    case NE :
1597 +      return CCWZmode;
1598 +
1599 +    case GE :
1600 +    case LT :
1601 +      if (y == const0_rtx)
1602 +       return CCWZNmode;
1603 +
1604 +    default :
1605 +      return CCWmode;
1606 +    }
1607 +}
1608 +
1609 +/* Return TRUE or FALSE depending on whether the first SET in INSN
1610 +   has source and destination with matching CC modes, and that the
1611 +   CC mode is at least as constrained as REQ_MODE.  */
1612 +bool
1613 +ubicom32_match_cc_mode (rtx insn, enum machine_mode req_mode)
1614 +{
1615 +  rtx set;
1616 +  enum machine_mode set_mode;
1617 +
1618 +  set = PATTERN (insn);
1619 +  if (GET_CODE (set) == PARALLEL)
1620 +    set = XVECEXP (set, 0, 0);
1621 +  gcc_assert (GET_CODE (set) == SET);
1622 +  gcc_assert (GET_CODE (SET_SRC (set)) == COMPARE);
1623 +
1624 +  /* SET_MODE is the mode we have in the instruction.  This must either
1625 +     be the same or less restrictive that the required mode REQ_MODE.  */
1626 +  set_mode = GET_MODE (SET_DEST (set));
1627 +
1628 +  switch (req_mode)
1629 +    {
1630 +    case CCSZmode:
1631 +      if (set_mode != CCSZmode)
1632 +       return 0;
1633 +      break;
1634 +
1635 +    case CCSZNmode:
1636 +      if (set_mode != CCSZmode
1637 +         && set_mode != CCSZNmode)
1638 +       return 0;
1639 +      break;
1640 +
1641 +    case CCSmode:
1642 +      if (set_mode != CCSmode
1643 +         && set_mode != CCSZmode
1644 +         && set_mode != CCSZNmode)
1645 +       return 0;
1646 +      break;
1647 +
1648 +    case CCWZmode:
1649 +      if (set_mode != CCWZmode)
1650 +       return 0;
1651 +      break;
1652 +
1653 +    case CCWZNmode:
1654 +      if (set_mode != CCWZmode
1655 +         && set_mode != CCWZNmode)
1656 +       return 0;
1657 +      break;
1658 +
1659 +    case CCWmode:
1660 +      if (set_mode != CCWmode
1661 +         && set_mode != CCWZmode
1662 +         && set_mode != CCWZNmode)
1663 +       return 0;
1664 +      break;
1665 +
1666 +    default:
1667 +      gcc_unreachable ();
1668 +    }
1669 +
1670 +  return (GET_MODE (SET_SRC (set)) == set_mode);
1671 +}
1672 +
1673 +/* Replace the comparison OP0 CODE OP1 by a semantically equivalent one
1674 +   that we can implement more efficiently.  */
1675 +
1676 +void
1677 +ubicom32_canonicalize_comparison (enum rtx_code *code, rtx *op0, rtx *op1)
1678 +{
1679 +  /* If we have a REG and a MEM then compare the MEM with the REG and not
1680 +     the other way round.  */
1681 +  if (REG_P (*op0) && MEM_P (*op1))
1682 +    {
1683 +      rtx tem = *op0;
1684 +      *op0 = *op1;
1685 +      *op1 = tem;
1686 +      *code = swap_condition (*code);
1687 +      return;
1688 +    }
1689 +
1690 +  /* If we have a REG and a CONST_INT then we may want to reverse things
1691 +     if the constant can be represented as an "I" constraint.  */
1692 +  if (REG_P (*op0) && CONST_INT_P (*op1) && satisfies_constraint_I (*op1))
1693 +    {
1694 +      rtx tem = *op0;
1695 +      *op0 = *op1;
1696 +      *op1 = tem;
1697 +      *code = swap_condition (*code);
1698 +      return;
1699 +    }
1700 +}
1701 +
1702 +/* Return the fixed registers used for condition codes.  */
1703 +
1704 +static bool
1705 +ubicom32_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
1706 +{
1707 +  *p1 = CC_REGNUM;
1708 +  *p2 = INVALID_REGNUM;
1709 +
1710 +  return true;
1711 +}
1712 +
1713 +/* If two condition code modes are compatible, return a condition code
1714 +   mode which is compatible with both.  Otherwise, return
1715 +   VOIDmode.  */
1716 +
1717 +static enum machine_mode
1718 +ubicom32_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
1719 +{
1720 +  if (m1 == m2)
1721 +    return m1;
1722 +
1723 +  if (GET_MODE_CLASS (m1) != MODE_CC || GET_MODE_CLASS (m2) != MODE_CC)
1724 +    return VOIDmode;
1725 +
1726 +  switch (m1)
1727 +    {
1728 +    case CCWmode:
1729 +      if (m2 == CCWZNmode || m2 == CCWZmode)
1730 +       return m1;
1731 +
1732 +      return VOIDmode;
1733 +
1734 +    case CCWZNmode:
1735 +      if (m2 == CCWmode)
1736 +       return m2;
1737 +
1738 +      if (m2 == CCWZmode)
1739 +       return m1;
1740 +
1741 +      return VOIDmode;
1742 +
1743 +    case CCWZmode:
1744 +      if (m2 == CCWmode || m2 == CCWZNmode)
1745 +       return m2;
1746 +
1747 +      return VOIDmode;
1748 +
1749 +    case CCSmode:
1750 +      if (m2 == CCSZNmode || m2 == CCSZmode)
1751 +       return m1;
1752 +
1753 +      return VOIDmode;
1754 +
1755 +    case CCSZNmode:
1756 +      if (m2 == CCSmode)
1757 +       return m2;
1758 +
1759 +      if (m2 == CCSZmode)
1760 +       return m1;
1761 +
1762 +      return VOIDmode;
1763 +
1764 +    case CCSZmode:
1765 +      if (m2 == CCSmode || m2 == CCSZNmode)
1766 +       return m2;
1767 +
1768 +      return VOIDmode;
1769 +
1770 +    default:
1771 +      gcc_unreachable ();
1772 +    }
1773 +}
1774 +
1775 +static rtx
1776 +ubicom32_legitimize_fdpic_address_symbol (rtx orig, rtx reg, rtx fdpic_reg)
1777 +{
1778 +  int unspec;
1779 +  rtx got_offs;
1780 +  rtx got_offs_scaled;
1781 +  rtx plus_scaled;
1782 +  rtx tmp;
1783 +  rtx new_rtx;
1784 +
1785 +  gcc_assert (reg != 0);
1786 +
1787 +  if (GET_CODE (orig) == SYMBOL_REF
1788 +      && SYMBOL_REF_FUNCTION_P (orig))
1789 +    unspec = UNSPEC_FDPIC_GOT_FUNCDESC;
1790 +  else
1791 +    unspec = UNSPEC_FDPIC_GOT;
1792 +
1793 +  got_offs = gen_reg_rtx (SImode);
1794 +  tmp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, orig), unspec);
1795 +  emit_move_insn (got_offs, tmp);
1796 +
1797 +  got_offs_scaled = gen_rtx_MULT (SImode, got_offs, GEN_INT (4));
1798 +  plus_scaled = gen_rtx_PLUS (Pmode, fdpic_reg, got_offs_scaled);
1799 +  new_rtx = gen_const_mem (Pmode, plus_scaled);
1800 +  emit_move_insn (reg, new_rtx);
1801 +
1802 +  return reg;
1803 +}
1804 +
1805 +static rtx
1806 +ubicom32_legitimize_fdpic_address (rtx orig, rtx reg, rtx fdpic_reg)
1807 +{
1808 +  rtx addr = orig;
1809 +  rtx new_rtx = orig;
1810 +
1811 +  if (GET_CODE (addr) == CONST || GET_CODE (addr) == PLUS)
1812 +    {
1813 +      rtx base;
1814 +
1815 +      if (GET_CODE (addr) == CONST)
1816 +       {
1817 +         addr = XEXP (addr, 0);
1818 +         gcc_assert (GET_CODE (addr) == PLUS);
1819 +       }
1820 +
1821 +      base = ubicom32_legitimize_fdpic_address_symbol (XEXP (addr, 0), reg, fdpic_reg);
1822 +      return gen_rtx_PLUS (Pmode, base, XEXP (addr, 1));
1823 +    }
1824 +
1825 +  return new_rtx;
1826 +}
1827 +
1828 +/* Code generation.  */
1829 +
1830 +void
1831 +ubicom32_expand_movsi (rtx *operands)
1832 +{
1833 +  if (GET_CODE (operands[1]) == SYMBOL_REF
1834 +      || (GET_CODE (operands[1]) == CONST
1835 +         && GET_CODE (XEXP (operands[1], 0)) == PLUS
1836 +         && GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == SYMBOL_REF)
1837 +      || CONSTANT_ADDRESS_P (operands[1]))
1838 +    {
1839 +      if (TARGET_FDPIC)
1840 +       {
1841 +         rtx tmp;
1842 +         rtx fdpic_reg;
1843 +
1844 +         gcc_assert (can_create_pseudo_p ());
1845 +         tmp = gen_reg_rtx (Pmode);
1846 +         fdpic_reg = get_hard_reg_initial_val (SImode, FDPIC_REGNUM);
1847 +         if (GET_CODE (operands[1]) == SYMBOL_REF
1848 +             || GET_CODE (operands[1]) == LABEL_REF)
1849 +           operands[1] = ubicom32_legitimize_fdpic_address_symbol (operands[1], tmp, fdpic_reg);
1850 +         else
1851 +           operands[1] = ubicom32_legitimize_fdpic_address (operands[1], tmp, fdpic_reg);
1852 +       }
1853 +      else
1854 +       {
1855 +         rtx tmp;
1856 +         enum machine_mode mode;
1857 +
1858 +         /* We want to avoid reusing operand 0 if we can because it limits
1859 +            our ability to optimize later.  */
1860 +         tmp = ! can_create_pseudo_p () ? operands[0] : gen_reg_rtx (Pmode);
1861 +
1862 +         mode = GET_MODE (operands[0]);
1863 +         emit_insn (gen_rtx_SET (VOIDmode, tmp,
1864 +                                 gen_rtx_HIGH (mode, operands[1])));
1865 +         operands[1] = gen_rtx_LO_SUM (mode, tmp, operands[1]);
1866 +         if (can_create_pseudo_p() && ! REG_P (operands[0]))
1867 +           {
1868 +             tmp = gen_reg_rtx (mode);
1869 +             emit_insn (gen_rtx_SET (VOIDmode, tmp, operands[1]));
1870 +             operands[1] = tmp;
1871 +           }
1872 +       }
1873 +    }
1874 +}
1875 +
1876 +/* Emit code for addsi3.  */
1877 +
1878 +void
1879 +ubicom32_expand_addsi3 (rtx *operands)
1880 +{
1881 +  rtx op, clob;
1882 +
1883 +  if (can_create_pseudo_p ())
1884 +    {
1885 +      /* If we have a non-data reg for operand 1 then prefer that over
1886 +         a CONST_INT in operand 2.  */
1887 +      if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
1888 +         && CONST_INT_P (operands[2]))
1889 +       operands[2] = copy_to_mode_reg (SImode, operands[2]);
1890 +
1891 +      if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
1892 +       operands[2] = copy_to_mode_reg (SImode, operands[2]);
1893 +    }
1894 +
1895 +  /* Emit the instruction.  */
1896 +
1897 +  op = gen_rtx_SET (VOIDmode, operands[0],
1898 +                   gen_rtx_PLUS (SImode, operands[1], operands[2]));
1899 +
1900 +  if (! can_create_pseudo_p ())
1901 +    {
1902 +      /* Reload doesn't know about the flags register, and doesn't know that
1903 +         it doesn't want to clobber it.  We can only do this with PLUS.  */
1904 +      emit_insn (op);
1905 +    }
1906 +  else
1907 +    {
1908 +      clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
1909 +      emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
1910 +    }
1911 +}
1912 +
1913 +/* Emit code for mulsi3.  Return 1 if we have generated all the code
1914 +   necessary to do the multiplication.  */
1915 +
1916 +int
1917 +ubicom32_emit_mult_sequence (rtx *operands)
1918 +{
1919 +  if (! ubicom32_v4)
1920 +    {
1921 +      rtx a1, a1_1, a2;
1922 +      rtx b1, b1_1, b2;
1923 +      rtx mac_lo_rtx;
1924 +      rtx t1, t2, t3;
1925 +
1926 +      /* Give up if we cannot create new pseudos.  */
1927 +      if (!can_create_pseudo_p())
1928 +       return 0;
1929 +
1930 +      /* Synthesize 32-bit multiplication using 16-bit operations:
1931 +
1932 +        a1 = highpart (a)
1933 +        a2 = lowpart (a)
1934 +
1935 +        b1 = highpart (b)
1936 +        b2 = lowpart (b)
1937 +
1938 +        c = (a1 * b1) << 32 + (a1 * b2) << 16 + (a2 * b1) << 16 + a2 * b2
1939 +          =        0        + (a1 * b2) << 16 + (a2 * b1) << 16 + a2 * b2
1940 +                              ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^   ^^^^^^^
1941 +                                  Signed             Signed      Unsigned  */
1942 +
1943 +      if (!ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])))
1944 +       {
1945 +         rtx op1;
1946 +
1947 +         op1 = gen_reg_rtx (SImode);
1948 +         emit_move_insn (op1, operands[1]);
1949 +         operands[1] = op1;
1950 +       }
1951 +
1952 +      if (!ubicom32_data_register_operand (operands[2], GET_MODE (operands[2])))
1953 +       {
1954 +         rtx op2;
1955 +
1956 +         op2 = gen_reg_rtx (SImode);
1957 +         emit_move_insn (op2, operands[2]);
1958 +         operands[2] = op2;
1959 +       }
1960 +
1961 +      /* a1 = highpart (a)  */
1962 +      a1 = gen_reg_rtx (HImode);
1963 +      a1_1 = gen_reg_rtx (SImode);
1964 +      emit_insn (gen_ashrsi3 (a1_1, operands[1], GEN_INT (16)));
1965 +      emit_move_insn (a1, gen_lowpart (HImode, a1_1));
1966 +
1967 +      /* a2 = lowpart (a)  */
1968 +      a2 = gen_reg_rtx (HImode);
1969 +      emit_move_insn (a2, gen_lowpart (HImode, operands[1]));
1970 +
1971 +      /* b1 = highpart (b)  */
1972 +      b1 = gen_reg_rtx (HImode);
1973 +      b1_1 = gen_reg_rtx (SImode);
1974 +      emit_insn (gen_ashrsi3 (b1_1, operands[2], GEN_INT (16)));
1975 +      emit_move_insn (b1, gen_lowpart (HImode, b1_1));
1976 +
1977 +      /* b2 = lowpart (b)  */
1978 +      b2 = gen_reg_rtx (HImode);
1979 +      emit_move_insn (b2, gen_lowpart (HImode, operands[2]));
1980 +
1981 +      /* t1 = (a1 * b2) << 16  */
1982 +      t1 = gen_reg_rtx (SImode);
1983 +      mac_lo_rtx = gen_rtx_REG (SImode, ACC0_LO_REGNUM);
1984 +      emit_insn (gen_mulhisi3 (mac_lo_rtx, a1, b2));
1985 +      emit_insn (gen_ashlsi3 (t1, mac_lo_rtx, GEN_INT (16)));
1986 +
1987 +      /* t2 = (a2 * b1) << 16  */
1988 +      t2 = gen_reg_rtx (SImode);
1989 +      emit_insn (gen_mulhisi3 (mac_lo_rtx, a2, b1));
1990 +      emit_insn (gen_ashlsi3 (t2, mac_lo_rtx, GEN_INT (16)));
1991 +
1992 +      /* mac_lo = a2 * b2  */
1993 +      emit_insn (gen_umulhisi3 (mac_lo_rtx, a2, b2));
1994 +
1995 +      /* t3 = t1 + t2  */
1996 +      t3 = gen_reg_rtx (SImode);
1997 +      emit_insn (gen_addsi3 (t3, t1, t2));
1998 +
1999 +      /* c = t3 + mac_lo_rtx  */
2000 +      emit_insn (gen_addsi3 (operands[0], mac_lo_rtx, t3));
2001 +
2002 +      return 1;
2003 +    }
2004 +  else
2005 +    {
2006 +      rtx acc_rtx;
2007 +
2008 +      /* Give up if we cannot create new pseudos.  */
2009 +      if (!can_create_pseudo_p())
2010 +       return 0;
2011 +
2012 +      if (!ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])))
2013 +        {
2014 +         rtx op1;
2015 +
2016 +         op1 = gen_reg_rtx (SImode);
2017 +         emit_move_insn (op1, operands[1]);
2018 +         operands[1] = op1;
2019 +       }
2020 +
2021 +      if (!ubicom32_data_register_operand (operands[2], GET_MODE (operands[2])))
2022 +       {
2023 +         rtx op2;
2024 +
2025 +         op2 = gen_reg_rtx (SImode);
2026 +         emit_move_insn (op2, operands[2]);
2027 +         operands[2] = op2;
2028 +       }
2029 +
2030 +      acc_rtx = gen_reg_rtx (DImode);
2031 +      emit_insn (gen_umulsidi3 (acc_rtx, operands[1], operands[2]));
2032 +      emit_move_insn (operands[0], gen_lowpart (SImode, acc_rtx));
2033 +
2034 +      return 1;
2035 +    }
2036 +}
2037 +
2038 +/* Move the integer value VAL into OPERANDS[0].  */
2039 +
2040 +void
2041 +ubicom32_emit_move_const_int (rtx dest, rtx imm)
2042 +{
2043 +  rtx xoperands[2];
2044 +
2045 +  xoperands[0] = dest;
2046 +  xoperands[1] = imm;
2047 +
2048 +  /* Treat mem destinations separately.  Values must be explicitly sign
2049 +     extended.  */
2050 +  if (MEM_P (dest))
2051 +    {
2052 +      rtx low_hword_mem;
2053 +      rtx low_hword_addr;
2054 +
2055 +      /* Emit shorter sequence for signed 7-bit quantities.  */
2056 +      if (satisfies_constraint_I (imm))
2057 +       {
2058 +          output_asm_insn ("move.4\t%0, %1", xoperands);
2059 +          return;
2060 +       }
2061 +
2062 +      /* Special case for pushing constants.  */
2063 +      if (GET_CODE (XEXP (dest, 0)) == PRE_DEC
2064 +         && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx)
2065 +       {
2066 +         output_asm_insn ("movei\t-4(sp)++, #%%hi(%E1)", xoperands);
2067 +         output_asm_insn ("movei\t2(sp), #%%lo(%E1)", xoperands);
2068 +         return;
2069 +       }
2070 +
2071 +      /* See if we can add 2 to the original address.  This is only
2072 +        possible if the original address is of the form REG or
2073 +        REG+const.  */
2074 +      low_hword_addr = plus_constant (XEXP (dest, 0), 2);
2075 +      if (ubicom32_legitimate_address_p (HImode, low_hword_addr, 1))
2076 +       {
2077 +         low_hword_mem = gen_rtx_MEM (HImode, low_hword_addr);
2078 +         MEM_COPY_ATTRIBUTES (low_hword_mem, dest);
2079 +         output_asm_insn ("movei\t%0, #%%hi(%E1)", xoperands);
2080 +         xoperands[0] = low_hword_mem;
2081 +         output_asm_insn ("movei\t%0, #%%lo(%E1)", xoperands);
2082 +         return;
2083 +       }
2084 +
2085 +      /* The original address is too complex.  We need to use a
2086 +        scratch memory by (sp) and move that to the original
2087 +        destination.  */
2088 +      if (! reg_mentioned_p (stack_pointer_rtx, dest))
2089 +       {
2090 +         output_asm_insn ("movei\t-4(sp)++, #%%hi(%E1)", xoperands);
2091 +         output_asm_insn ("movei\t2(sp), #%%lo(%E1)", xoperands);
2092 +         output_asm_insn ("move.4\t%0, (sp)4++", xoperands);
2093 +         return;
2094 +       }
2095 +
2096 +      /* Our address mentions the stack pointer so we need to
2097 +        use our scratch data register here as well as scratch
2098 +        memory.  */
2099 +      output_asm_insn ("movei\t-4(sp)++, #%%hi(%E1)", xoperands);
2100 +      output_asm_insn ("movei\t2(sp), #%%lo(%E1)", xoperands);
2101 +      output_asm_insn ("move.4\td15, (sp)4++", xoperands);
2102 +      output_asm_insn ("move.4\t%0, d15", xoperands);
2103 +      return;
2104 +    }
2105 +
2106 +  /* Move into registers are zero extended by default.  */
2107 +  if (! REG_P (dest))
2108 +    abort ();
2109 +
2110 +  if (satisfies_constraint_N (imm))
2111 +    {
2112 +      output_asm_insn ("movei\t%0, %1", xoperands);
2113 +      return;
2114 +    }
2115 +
2116 +  if (INTVAL (xoperands[1]) >= 0xff80
2117 +      && INTVAL (xoperands[1]) < 0x10000)
2118 +    {
2119 +      xoperands[1] = GEN_INT (INTVAL (xoperands[1]) - 0x10000);
2120 +      output_asm_insn ("move.2\t%0, %1", xoperands);
2121 +      return;
2122 +    }
2123 +
2124 +  if ((REGNO_REG_CLASS (REGNO (xoperands[0])) == ADDRESS_REGS
2125 +       || REGNO_REG_CLASS (REGNO (xoperands[0])) == FDPIC_REG)
2126 +      && ((INTVAL (xoperands[1]) & 0x80000000) == 0))
2127 +    {
2128 +      output_asm_insn ("moveai\t%0, #%%hi(%E1)", xoperands);
2129 +      if ((INTVAL (xoperands[1]) & 0x7f) != 0)
2130 +       output_asm_insn ("lea.1\t%0, %%lo(%E1)(%0)", xoperands);
2131 +      return;
2132 +    }
2133 +
2134 +  if ((INTVAL (xoperands[1]) & 0xffff0000) == 0)
2135 +    {
2136 +      output_asm_insn ("movei\t%0, #%%lo(%E1)", xoperands);
2137 +      output_asm_insn ("move.2\t%0, %0", xoperands);
2138 +      return;
2139 +    }
2140 +
2141 +  /* This is very expensive.  The constant is so large that we
2142 +     need to use the stack to do the load.  */
2143 +  output_asm_insn ("movei\t-4(sp)++, #%%hi(%E1)", xoperands);
2144 +  output_asm_insn ("movei\t2(sp), #%%lo(%E1)", xoperands);
2145 +  output_asm_insn ("move.4\t%0, (sp)4++", xoperands);
2146 +}
2147 +
2148 +/* Stack layout. Prologue/Epilogue.  */
2149 +
2150 +static int save_regs_size;
2151 +
2152 +static void
2153 +ubicom32_layout_frame (void)
2154 +{
2155 +  int regno;
2156 +
2157 +  memset ((char *) &save_regs[0], 0, sizeof (save_regs));
2158 +  nregs = 0;
2159 +  frame_size = get_frame_size ();
2160 +
2161 +  if (frame_pointer_needed || df_regs_ever_live_p (FRAME_POINTER_REGNUM))
2162 +    {
2163 +      save_regs[FRAME_POINTER_REGNUM] = 1;
2164 +      ++nregs;
2165 +    }
2166 +
2167 +  if (current_function_is_leaf && ! df_regs_ever_live_p (LINK_REGNO))
2168 +    ubicom32_can_use_calli_to_ret = 1;
2169 +  else
2170 +    {
2171 +      ubicom32_can_use_calli_to_ret = 0;
2172 +      save_regs[LINK_REGNO] = 1;
2173 +      ++nregs;
2174 +    }
2175 +
2176 +  /* Figure out which register(s) needs to be saved.  */
2177 +  for (regno = 0; regno <= LAST_ADDRESS_REGNUM; regno++)
2178 +       if (df_regs_ever_live_p(regno)
2179 +       && ! call_used_regs[regno]
2180 +       && ! fixed_regs[regno]
2181 +       && ! save_regs[regno])
2182 +    {
2183 +      save_regs[regno] = 1;
2184 +      ++nregs;
2185 +    }
2186 +
2187 +  save_regs_size = 4 * nregs;
2188 +}
2189 +
2190 +static void
2191 +ubicom32_emit_add_movsi (int regno, int adj)
2192 +{
2193 +  rtx x;
2194 +  rtx reg = gen_rtx_REG (SImode, regno);
2195 +
2196 +  adj += 4;
2197 +  if (adj > 8 * 4)
2198 +    {
2199 +      x = emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
2200 +                                GEN_INT (-adj)));
2201 +      RTX_FRAME_RELATED_P (x) = 1;
2202 +      x = emit_move_insn (gen_rtx_MEM (SImode, stack_pointer_rtx), reg);
2203 +    }
2204 +  else
2205 +    {
2206 +      rtx addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx,
2207 +                                    gen_rtx_PLUS (Pmode, stack_pointer_rtx,
2208 +                                                  GEN_INT (-adj)));
2209 +      x = emit_move_insn (gen_rtx_MEM (SImode, addr), reg);
2210 +    }
2211 +  RTX_FRAME_RELATED_P (x) = 1;
2212 +}
2213 +
2214 +void
2215 +ubicom32_expand_prologue (void)
2216 +{
2217 +  rtx x;
2218 +  int regno;
2219 +  int outgoing_args_size = crtl->outgoing_args_size;
2220 +  int adj;
2221 +
2222 +  if (ubicom32_naked_function_p ())
2223 +    return;
2224 +
2225 +  ubicom32_builtin_saveregs ();
2226 +
2227 +  ubicom32_layout_frame ();
2228 +  adj = (outgoing_args_size + get_frame_size () + save_regs_size
2229 +        + crtl->args.pretend_args_size);
2230 +
2231 +  if (!adj)
2232 +    ;
2233 +  else if (outgoing_args_size + save_regs_size < 508
2234 +          && get_frame_size () + save_regs_size > 508)
2235 +    {
2236 +      int i = 0;
2237 +      x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
2238 +                     GEN_INT (-adj));
2239 +      x = emit_insn (x);
2240 +      RTX_FRAME_RELATED_P (x) = 1;
2241 +
2242 +      for (regno = LAST_ADDRESS_REGNUM; regno >= 0; --regno)
2243 +       if (save_regs[regno] && regno != LINK_REGNO)
2244 +         {
2245 +           x = gen_rtx_MEM (SImode,
2246 +                            gen_rtx_PLUS (Pmode,
2247 +                                          stack_pointer_rtx,
2248 +                                          GEN_INT (i * 4 + outgoing_args_size)));
2249 +           x = emit_move_insn (x, gen_rtx_REG (SImode, regno));
2250 +           RTX_FRAME_RELATED_P (x) = 1;
2251 +           ++i;
2252 +         }
2253 +      if (save_regs[LINK_REGNO])
2254 +       {
2255 +         x = gen_rtx_MEM (SImode,
2256 +                          gen_rtx_PLUS (Pmode,
2257 +                                        stack_pointer_rtx,
2258 +                                        GEN_INT (i * 4 + outgoing_args_size)));
2259 +         x = emit_move_insn (x, gen_rtx_REG (SImode, LINK_REGNO));
2260 +         RTX_FRAME_RELATED_P (x) = 1;
2261 +       }
2262 +    }
2263 +  else
2264 +    {
2265 +      int regno;
2266 +      int adj = get_frame_size () + crtl->args.pretend_args_size;
2267 +      int i = 0;
2268 +
2269 +      if (save_regs[LINK_REGNO])
2270 +       {
2271 +         ubicom32_emit_add_movsi (LINK_REGNO, adj);
2272 +         ++i;
2273 +       }
2274 +
2275 +      for (regno = 0; regno <= LAST_ADDRESS_REGNUM; ++regno)
2276 +       if (save_regs[regno] && regno != LINK_REGNO)
2277 +         {
2278 +           if (i)
2279 +             {
2280 +               rtx mem = gen_rtx_MEM (SImode,
2281 +                                      gen_rtx_PRE_DEC (Pmode,
2282 +                                                       stack_pointer_rtx));
2283 +               x = emit_move_insn (mem, gen_rtx_REG (SImode, regno));
2284 +               RTX_FRAME_RELATED_P (x) = 1;
2285 +             }
2286 +           else
2287 +             ubicom32_emit_add_movsi (regno, adj);
2288 +           ++i;
2289 +         }
2290 +
2291 +      if (outgoing_args_size || (!i && adj))
2292 +       {
2293 +         x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
2294 +                         GEN_INT (-outgoing_args_size - (i ? 0 : adj)));
2295 +         x = emit_insn (x);
2296 +         RTX_FRAME_RELATED_P (x) = 1;
2297 +       }
2298 +    }
2299 +
2300 +  if (frame_pointer_needed)
2301 +    {
2302 +      int fp_adj = save_regs_size + outgoing_args_size;
2303 +      x = gen_addsi3 (frame_pointer_rtx, stack_pointer_rtx,
2304 +                     GEN_INT (fp_adj));
2305 +      x = emit_insn (x);
2306 +      RTX_FRAME_RELATED_P (x) = 1;
2307 +    }
2308 +}
2309 +
2310 +void
2311 +ubicom32_expand_epilogue (void)
2312 +{
2313 +  rtx x;
2314 +  int regno;
2315 +  int outgoing_args_size = crtl->outgoing_args_size;
2316 +  int adj;
2317 +  int i;
2318 +
2319 +  if (ubicom32_naked_function_p ())
2320 +    {
2321 +      emit_jump_insn (gen_return_internal (gen_rtx_REG (SImode,
2322 +                                                       LINK_REGNO)));
2323 +      return;
2324 +    }
2325 +
2326 +  if (cfun->calls_alloca)
2327 +    {
2328 +      x = gen_addsi3 (stack_pointer_rtx, frame_pointer_rtx,
2329 +                     GEN_INT (-save_regs_size));
2330 +      emit_insn (x);
2331 +      outgoing_args_size = 0;
2332 +    }
2333 +
2334 +  if (outgoing_args_size)
2335 +    {
2336 +      x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
2337 +                     GEN_INT (outgoing_args_size));
2338 +      emit_insn (x);
2339 +    }
2340 +
2341 +  i = 0;
2342 +  for (regno = LAST_ADDRESS_REGNUM; regno >= 0; --regno)
2343 +    if (save_regs[regno] && regno != LINK_REGNO)
2344 +      {
2345 +       x = gen_rtx_MEM (SImode, gen_rtx_POST_INC (Pmode, stack_pointer_rtx));
2346 +       emit_move_insn (gen_rtx_REG (SImode, regno), x);
2347 +       ++i;
2348 +      }
2349 +
2350 +  /* Do we have to adjust the stack after we've finished restoring regs?  */
2351 +  adj = get_frame_size() + crtl->args.pretend_args_size;
2352 +  if (cfun->stdarg)
2353 +    adj += UBICOM32_FUNCTION_ARG_REGS * UNITS_PER_WORD;
2354 +
2355 +#if 0
2356 +  if (crtl->calls_eh_return && 0)
2357 +    {
2358 +      if (save_regs[LINK_REGNO])
2359 +        {
2360 +          x = gen_rtx_MEM (SImode, gen_rtx_POST_INC (Pmode, stack_pointer_rtx));
2361 +          emit_move_insn (gen_rtx_REG (SImode, LINK_REGNO), x);
2362 +        }
2363 +
2364 +      if (adj)
2365 +        {
2366 +          x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
2367 +                         GEN_INT (adj));
2368 +          x = emit_insn (x);
2369 +        }
2370 +
2371 +      /* Perform the additional bump for __throw.  */
2372 +      emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
2373 +                            EH_RETURN_STACKADJ_RTX));
2374 +      emit_jump_insn (gen_eh_return_internal ());
2375 +      return;
2376 +    }
2377 +#endif
2378 +
2379 +  if (save_regs[LINK_REGNO])
2380 +    {
2381 +      if (adj >= 4 && adj <= (6 * 4))
2382 +        {
2383 +         x = GEN_INT (adj + 4);
2384 +          emit_jump_insn (gen_return_from_post_modify_sp (x));
2385 +         return;
2386 +        }
2387 +
2388 +      if (adj == 0)
2389 +       {
2390 +          x = gen_rtx_MEM (SImode, gen_rtx_POST_INC (Pmode, stack_pointer_rtx));
2391 +          emit_jump_insn (gen_return_internal (x));
2392 +          return;
2393 +       }
2394 +
2395 +      x = gen_rtx_MEM (SImode, gen_rtx_POST_INC (Pmode, stack_pointer_rtx));
2396 +      emit_move_insn (gen_rtx_REG (SImode, LINK_REGNO), x);
2397 +    }
2398 +
2399 +  if (adj)
2400 +    {
2401 +      x = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
2402 +                     GEN_INT (adj));
2403 +      x = emit_insn (x);
2404 +      adj = 0;
2405 +    }
2406 +
2407 +  /* Given that we've just done all the hard work here we may as well use
2408 +     a calli to return.  */
2409 +  ubicom32_can_use_calli_to_ret = 1;
2410 +  emit_jump_insn (gen_return_internal (gen_rtx_REG (SImode, LINK_REGNO)));
2411 +}
2412 +
2413 +void
2414 +ubicom32_expand_call_fdpic (rtx *operands)
2415 +{
2416 +  rtx c;
2417 +  rtx addr;
2418 +  rtx fdpic_reg = get_hard_reg_initial_val (SImode, FDPIC_REGNUM);
2419 +
2420 +  addr = XEXP (operands[0], 0);
2421 +
2422 +  c = gen_call_fdpic (addr, operands[1], fdpic_reg);
2423 +  emit_call_insn (c);
2424 +}
2425 +
2426 +void
2427 +ubicom32_expand_call_value_fdpic (rtx *operands)
2428 +{
2429 +  rtx c;
2430 +  rtx addr;
2431 +  rtx fdpic_reg = get_hard_reg_initial_val (SImode, FDPIC_REGNUM);
2432 +
2433 +  addr = XEXP (operands[1], 0);
2434 +
2435 +  c = gen_call_value_fdpic (operands[0], addr, operands[2], fdpic_reg);
2436 +  emit_call_insn (c);
2437 +}
2438 +
2439 +void
2440 +ubicom32_expand_eh_return (rtx *operands)
2441 +{
2442 +  if (REG_P (operands[0])
2443 +      || REGNO (operands[0]) != EH_RETURN_STACKADJ_REGNO)
2444 +    {
2445 +      rtx sp = EH_RETURN_STACKADJ_RTX;
2446 +      emit_move_insn (sp, operands[0]);
2447 +      operands[0] = sp;
2448 +    }
2449 +
2450 +  if (REG_P (operands[1])
2451 +      || REGNO (operands[1]) != EH_RETURN_HANDLER_REGNO)
2452 +    {
2453 +      rtx ra = EH_RETURN_HANDLER_RTX;
2454 +      emit_move_insn (ra, operands[1]);
2455 +      operands[1] = ra;
2456 +    }
2457 +}
2458 +
2459 +/* Compute the offsets between eliminable registers.  */
2460 +
2461 +int
2462 +ubicom32_initial_elimination_offset (int from, int to)
2463 +{
2464 +  ubicom32_layout_frame ();
2465 +  if (from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
2466 +    return save_regs_size + crtl->outgoing_args_size;
2467 +
2468 +  if (from == ARG_POINTER_REGNUM && to == FRAME_POINTER_REGNUM)
2469 +    return get_frame_size ()/* + save_regs_size */;
2470 +
2471 +  if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
2472 +    return get_frame_size ()
2473 +          + crtl->outgoing_args_size
2474 +          + save_regs_size;
2475 +
2476 +  return 0;
2477 +}
2478 +
2479 +/* Return 1 if it is appropriate to emit `ret' instructions in the
2480 +   body of a function.  Do this only if the epilogue is simple, needing a
2481 +   couple of insns.  Prior to reloading, we can't tell how many registers
2482 +   must be saved, so return 0 then.  Return 0 if there is no frame
2483 +   marker to de-allocate.
2484 +
2485 +   If NON_SAVING_SETJMP is defined and true, then it is not possible
2486 +   for the epilogue to be simple, so return 0.  This is a special case
2487 +   since NON_SAVING_SETJMP will not cause regs_ever_live to change
2488 +   until final, but jump_optimize may need to know sooner if a
2489 +   `return' is OK.  */
2490 +
2491 +int
2492 +ubicom32_can_use_return_insn_p (void)
2493 +{
2494 +  if (! reload_completed || frame_pointer_needed)
2495 +    return 0;
2496 +
2497 +  return 1;
2498 +}
2499 +
2500 +/* Attributes and CC handling.  */
2501 +
2502 +/* Handle an attribute requiring a FUNCTION_DECL; arguments as in
2503 +   struct attribute_spec.handler.  */
2504 +static tree
2505 +ubicom32_handle_fndecl_attribute (tree *node, tree name,
2506 +                             tree args ATTRIBUTE_UNUSED,
2507 +                             int flags ATTRIBUTE_UNUSED,
2508 +                             bool *no_add_attrs)
2509 +{
2510 +  if (TREE_CODE (*node) != FUNCTION_DECL)
2511 +    {
2512 +      warning ("'%s' attribute only applies to functions",
2513 +              IDENTIFIER_POINTER (name));
2514 +      *no_add_attrs = true;
2515 +    }
2516 +
2517 +  return NULL_TREE;
2518 +}
2519 +
2520 +/* A C expression that places additional restrictions on the register class to
2521 +   use when it is necessary to copy value X into a register in class CLASS.
2522 +   The value is a register class; perhaps CLASS, or perhaps another, smaller
2523 +   class.  On many machines, the following definition is safe:
2524 +
2525 +        #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
2526 +
2527 +   Sometimes returning a more restrictive class makes better code.  For
2528 +   example, on the 68000, when X is an integer constant that is in range for a
2529 +   `moveq' instruction, the value of this macro is always `DATA_REGS' as long
2530 +   as CLASS includes the data registers.  Requiring a data register guarantees
2531 +   that a `moveq' will be used.
2532 +
2533 +   If X is a `const_double', by returning `NO_REGS' you can force X into a
2534 +   memory constant.  This is useful on certain machines where immediate
2535 +   floating values cannot be loaded into certain kinds of registers.  */
2536 +
2537 +enum reg_class
2538 +ubicom32_preferred_reload_class (rtx x, enum reg_class class)
2539 +{
2540 +  /* If a symbolic constant, HIGH or a PLUS is reloaded,
2541 +     it is most likely being used as an address, so
2542 +     prefer ADDRESS_REGS.  If 'class' is not a superset
2543 +     of ADDRESS_REGS, e.g. DATA_REGS, then reject this reload.  */
2544 +  if (GET_CODE (x) == PLUS
2545 +      || GET_CODE (x) == HIGH
2546 +      || GET_CODE (x) == LABEL_REF
2547 +      || GET_CODE (x) == SYMBOL_REF
2548 +      || GET_CODE (x) == CONST)
2549 +    {
2550 +      if (reg_class_subset_p (ALL_ADDRESS_REGS, class))
2551 +       return ALL_ADDRESS_REGS;
2552 +
2553 +      return NO_REGS;
2554 +    }
2555 +
2556 +  return class;
2557 +}
2558 +
2559 +/* Function arguments and varargs.  */
2560 +
2561 +int
2562 +ubicom32_reg_parm_stack_space (tree fndecl)
2563 +{
2564 +  return 0;
2565 +
2566 +  if (fndecl
2567 +      && TYPE_ARG_TYPES (TREE_TYPE (fndecl)) != 0
2568 +      && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
2569 +         != void_type_node))
2570 +    return UBICOM32_FUNCTION_ARG_REGS * UNITS_PER_WORD;
2571 +
2572 +  return 0;
2573 +}
2574 +
2575 +/* Flush the argument registers to the stack for a stdarg function;
2576 +   return the new argument pointer.  */
2577 +
2578 +rtx
2579 +ubicom32_builtin_saveregs (void)
2580 +{
2581 +  int regno;
2582 +
2583 +  if (! cfun->stdarg)
2584 +    return 0;
2585 +
2586 +  for (regno = UBICOM32_FUNCTION_ARG_REGS - 1; regno >= 0; --regno)
2587 +    emit_move_insn (gen_rtx_MEM (SImode,
2588 +                                gen_rtx_PRE_DEC (SImode,
2589 +                                                 stack_pointer_rtx)),
2590 +                   gen_rtx_REG (SImode, regno));
2591 +
2592 +  return stack_pointer_rtx;
2593 +}
2594 +
2595 +void
2596 +ubicom32_va_start (tree valist, rtx nextarg)
2597 +{
2598 +  std_expand_builtin_va_start (valist, nextarg);
2599 +}
2600 +
2601 +rtx
2602 +ubicom32_va_arg (tree valist, tree type)
2603 +{
2604 +  HOST_WIDE_INT size, rsize;
2605 +  tree addr, incr, tmp;
2606 +  rtx addr_rtx;
2607 +  int indirect = 0;
2608 +
2609 +  /* Round up sizeof(type) to a word.  */
2610 +  size = int_size_in_bytes (type);
2611 +  rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
2612 +
2613 +  /* Large types are passed by reference.  */
2614 +  if (size > 8)
2615 +    {
2616 +      indirect = 1;
2617 +      size = rsize = UNITS_PER_WORD;
2618 +    }
2619 +
2620 +  incr = valist;
2621 +  addr = incr = save_expr (incr);
2622 +
2623 +  /* FIXME Nat's version - is it correct?  */
2624 +  tmp = fold_convert (ptr_type_node, size_int (rsize));
2625 +  tmp = build2 (PLUS_EXPR, ptr_type_node, incr, tmp);
2626 +  incr = fold (tmp);
2627 +
2628 +  /* FIXME Nat's version - is it correct? */
2629 +  incr = build2 (MODIFY_EXPR, ptr_type_node, valist, incr);
2630 +
2631 +  TREE_SIDE_EFFECTS (incr) = 1;
2632 +  expand_expr (incr, const0_rtx, VOIDmode, EXPAND_NORMAL);
2633 +
2634 +  addr_rtx = expand_expr (addr, NULL, Pmode, EXPAND_NORMAL);
2635 +
2636 +  if (size < UNITS_PER_WORD)
2637 +    emit_insn (gen_addsi3 (addr_rtx, addr_rtx,
2638 +                          GEN_INT (UNITS_PER_WORD - size)));
2639 +
2640 +  if (indirect)
2641 +    {
2642 +      addr_rtx = force_reg (Pmode, addr_rtx);
2643 +      addr_rtx = gen_rtx_MEM (Pmode, addr_rtx);
2644 +      set_mem_alias_set (addr_rtx, get_varargs_alias_set ());
2645 +    }
2646 +
2647 +  return addr_rtx;
2648 +}
2649 +
2650 +void
2651 +init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype, rtx libname,
2652 +                     int indirect ATTRIBUTE_UNUSED)
2653 +{
2654 +  cum->nbytes = 0;
2655 +
2656 +  if (!libname)
2657 +    {
2658 +      cum->stdarg = (TYPE_ARG_TYPES (fntype) != 0
2659 +                    && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
2660 +                        != void_type_node));
2661 +    }
2662 +}
2663 +
2664 +/* Return an RTX to represent where a value in mode MODE will be passed
2665 +   to a function.  If the result is 0, the argument will be pushed.  */
2666 +
2667 +rtx
2668 +function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type,
2669 +             int named ATTRIBUTE_UNUSED)
2670 +{
2671 +  rtx result = 0;
2672 +  int size, align;
2673 +  int nregs = UBICOM32_FUNCTION_ARG_REGS;
2674 +
2675 +  /* Figure out the size of the object to be passed.  */
2676 +  if (mode == BLKmode)
2677 +    size = int_size_in_bytes (type);
2678 +  else
2679 +    size = GET_MODE_SIZE (mode);
2680 +
2681 +  /* Figure out the alignment of the object to be passed.  */
2682 +  align = size;
2683 +
2684 +  cum->nbytes = (cum->nbytes + 3) & ~3;
2685 +
2686 +  /* Don't pass this arg via a register if all the argument registers
2687 +     are used up.  */
2688 +  if (cum->nbytes >= nregs * UNITS_PER_WORD)
2689 +    return 0;
2690 +
2691 +  /* Don't pass this arg via a register if it would be split between
2692 +     registers and memory.  */
2693 +  result = gen_rtx_REG (mode, cum->nbytes / UNITS_PER_WORD);
2694 +
2695 +  return result;
2696 +}
2697 +
2698 +rtx
2699 +function_incoming_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type,
2700 +                      int named ATTRIBUTE_UNUSED)
2701 +{
2702 +  if (cfun->stdarg)
2703 +    return 0;
2704 +
2705 +  return function_arg (cum, mode, type, named);
2706 +}
2707 +
2708 +
2709 +/* Implement hook TARGET_ARG_PARTIAL_BYTES.
2710 +
2711 +   Returns the number of bytes at the beginning of an argument that
2712 +   must be put in registers.  The value must be zero for arguments
2713 +   that are passed entirely in registers or that are entirely pushed
2714 +   on the stack.  */
2715 +static int
2716 +ubicom32_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
2717 +                           tree type, bool named ATTRIBUTE_UNUSED)
2718 +{
2719 +  int size, diff;
2720 +
2721 +  int nregs = UBICOM32_FUNCTION_ARG_REGS;
2722 +
2723 +  /* round up to full word */
2724 +  cum->nbytes = (cum->nbytes + 3) & ~3;
2725 +
2726 +  if (targetm.calls.pass_by_reference (cum, mode, type, named))
2727 +      return 0;
2728 +
2729 +  /* number of bytes left in registers */
2730 +  diff = nregs*UNITS_PER_WORD - cum->nbytes;
2731 +
2732 +  /* regs all used up */
2733 +  if (diff <= 0)
2734 +    return 0;
2735 +
2736 +  /* Figure out the size of the object to be passed.  */
2737 +  if (mode == BLKmode)
2738 +    size = int_size_in_bytes (type);
2739 +  else
2740 +    size = GET_MODE_SIZE (mode);
2741 +
2742 +  /* enough space left in regs for size */
2743 +  if (size <= diff)
2744 +    return 0;
2745 +
2746 +  /* put diff bytes in regs and rest on stack */
2747 +  return diff;
2748 +
2749 +}
2750 +
2751 +static bool
2752 +ubicom32_pass_by_reference (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
2753 +                           enum machine_mode mode, const_tree type,
2754 +                           bool named ATTRIBUTE_UNUSED)
2755 +{
2756 +  int size;
2757 +
2758 +  if (type)
2759 +    size = int_size_in_bytes (type);
2760 +  else
2761 +    size = GET_MODE_SIZE (mode);
2762 +
2763 +  return size <= 0 || size > 8;
2764 +}
2765 +
2766 +static bool
2767 +ubicom32_callee_copies (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
2768 +                       enum machine_mode mode, const_tree type,
2769 +                       bool named ATTRIBUTE_UNUSED)
2770 +{
2771 +  int size;
2772 +
2773 +  if (type)
2774 +    size = int_size_in_bytes (type);
2775 +  else
2776 +    size = GET_MODE_SIZE (mode);
2777 +
2778 +  return size <= 0 || size > 8;
2779 +}
2780 +
2781 +static bool
2782 +ubicom32_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
2783 +{
2784 +  int size, mode;
2785 +
2786 +  if (!type)
2787 +    return true;
2788 +
2789 +  size = int_size_in_bytes(type);
2790 +  if (size > 8)
2791 +    return true;
2792 +
2793 +  mode = TYPE_MODE(type);
2794 +  if (mode == BLKmode)
2795 +    return true;
2796 +
2797 +  return false;
2798 +}
2799 +
2800 +/* Return true if a given register number REGNO is acceptable for machine
2801 +   mode MODE.  */
2802 +bool
2803 +ubicom32_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode)
2804 +{
2805 +  /* If we're not at least a v3 ISA then ACC0_HI is only 16 bits.  */
2806 +  if (! ubicom32_v3)
2807 +    {
2808 +      if (regno == ACC0_HI_REGNUM)
2809 +       return (mode == QImode || mode == HImode);
2810 +    }
2811 +
2812 +  /* Only the flags reg can hold CCmode.  */
2813 +  if (GET_MODE_CLASS (mode) == MODE_CC)
2814 +    return regno == CC_REGNUM;
2815 +
2816 +  /* We restrict the choice of DImode registers to only being address,
2817 +     data or accumulator regs.  We also restrict them to only start on
2818 +     even register numbers so we never have to worry about partial
2819 +     overlaps between operands in instructions.  */
2820 +  if (GET_MODE_SIZE (mode) > 4)
2821 +    {
2822 +      switch (REGNO_REG_CLASS (regno))
2823 +       {
2824 +       case ADDRESS_REGS:
2825 +       case DATA_REGS:
2826 +       case ACC_REGS:
2827 +         return (regno & 1) == 0;
2828 +
2829 +        default:
2830 +         return false;
2831 +       }
2832 +    }
2833 +
2834 +  return true;
2835 +}
2836 +
2837 +/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
2838 +   and check its validity for a certain class.
2839 +   We have two alternate definitions for each of them.
2840 +   The usual definition accepts all pseudo regs; the other rejects
2841 +   them unless they have been allocated suitable hard regs.
2842 +   The symbol REG_OK_STRICT causes the latter definition to be used.
2843 +
2844 +   Most source files want to accept pseudo regs in the hope that
2845 +   they will get allocated to the class that the insn wants them to be in.
2846 +   Source files for reload pass need to be strict.
2847 +   After reload, it makes no difference, since pseudo regs have
2848 +   been eliminated by then.
2849 +
2850 +   These assume that REGNO is a hard or pseudo reg number.
2851 +   They give nonzero only if REGNO is a hard reg of the suitable class
2852 +   or a pseudo reg currently allocated to a suitable hard reg.
2853 +   Since they use reg_renumber, they are safe only once reg_renumber
2854 +   has been allocated, which happens in local-alloc.c.  */
2855 +
2856 +int
2857 +ubicom32_regno_ok_for_base_p (int regno, int strict)
2858 +{
2859 +  if ((regno >= FIRST_ADDRESS_REGNUM && regno <= STACK_POINTER_REGNUM)
2860 +      || (!strict
2861 +         && (regno >= FIRST_PSEUDO_REGISTER
2862 +             || regno == ARG_POINTER_REGNUM))
2863 +      || (strict && (reg_renumber
2864 +                    && reg_renumber[regno] >= FIRST_ADDRESS_REGNUM
2865 +                    && reg_renumber[regno] <= STACK_POINTER_REGNUM)))
2866 +    return 1;
2867 +
2868 +  return 0;
2869 +}
2870 +
2871 +int
2872 +ubicom32_regno_ok_for_index_p (int regno, int strict)
2873 +{
2874 +  if ((regno >= FIRST_DATA_REGNUM && regno <= LAST_DATA_REGNUM)
2875 +      || (!strict && regno >= FIRST_PSEUDO_REGISTER)
2876 +      || (strict && (reg_renumber
2877 +                    && reg_renumber[regno] >= FIRST_DATA_REGNUM
2878 +                    && reg_renumber[regno] <= LAST_DATA_REGNUM)))
2879 +    return 1;
2880 +
2881 +  return 0;
2882 +}
2883 +
2884 +/* Returns 1 if X is a valid index register.  STRICT is 1 if only hard
2885 +   registers should be accepted.  Accept either REG or SUBREG where a
2886 +   register is valid.  */
2887 +
2888 +static bool
2889 +ubicom32_is_index_reg (rtx x, int strict)
2890 +{
2891 +  if ((REG_P (x) && ubicom32_regno_ok_for_index_p (REGNO (x), strict))
2892 +      || (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x))
2893 +         && ubicom32_regno_ok_for_index_p (REGNO (SUBREG_REG (x)), strict)))
2894 +    return true;
2895 +
2896 +  return false;
2897 +}
2898 +
2899 +/* Return 1 if X is a valid index for a memory address.  */
2900 +
2901 +static bool
2902 +ubicom32_is_index_expr (enum machine_mode mode, rtx x, int strict)
2903 +{
2904 +  /* Immediate index must be an unsigned 7-bit offset multiple of 1, 2
2905 +     or 4 depending on mode.  */
2906 +  if (CONST_INT_P (x))
2907 +    {
2908 +      switch (mode)
2909 +       {
2910 +       case QImode:
2911 +         return satisfies_constraint_J (x);
2912 +
2913 +       case HImode:
2914 +         return satisfies_constraint_K (x);
2915 +
2916 +       case SImode:
2917 +       case SFmode:
2918 +         return satisfies_constraint_L (x);
2919 +
2920 +       case DImode:
2921 +         return satisfies_constraint_L (x)
2922 +                && satisfies_constraint_L (GEN_INT (INTVAL (x) + 4));
2923 +
2924 +       default:
2925 +         return false;
2926 +       }
2927 +    }
2928 +
2929 +  if (mode != SImode && mode != HImode && mode != QImode)
2930 +    return false;
2931 +
2932 +  /* Register index scaled by mode of operand: REG + REG * modesize.
2933 +     Valid scaled index registers are:
2934 +
2935 +     SImode    (mult (dreg) 4))
2936 +     HImode    (mult (dreg) 2))
2937 +     QImode    (mult (dreg) 1))  */
2938 +  if (GET_CODE (x) == MULT
2939 +      && ubicom32_is_index_reg (XEXP (x, 0), strict)
2940 +      && CONST_INT_P (XEXP (x, 1))
2941 +      && INTVAL (XEXP (x, 1)) == (HOST_WIDE_INT)GET_MODE_SIZE (mode))
2942 +    return true;
2943 +
2944 +  /* REG + REG addressing is allowed for QImode.  */
2945 +  if (ubicom32_is_index_reg (x, strict) && mode == QImode)
2946 +    return true;
2947 +
2948 +  return false;
2949 +}
2950 +
2951 +static bool
2952 +ubicom32_is_valid_offset (enum machine_mode mode, HOST_WIDE_INT offs)
2953 +{
2954 +  if (offs < 0)
2955 +    return false;
2956 +
2957 +  switch (mode)
2958 +    {
2959 +    case QImode:
2960 +      return offs <= 127;
2961 +
2962 +    case HImode:
2963 +      return offs <= 254;
2964 +
2965 +    case SImode:
2966 +    case SFmode:
2967 +      return offs <= 508;
2968 +
2969 +    case DImode:
2970 +      return offs <= 504;
2971 +
2972 +    default:
2973 +      return false;
2974 +    }
2975 +}
2976 +
2977 +static int
2978 +ubicom32_get_valid_offset_mask (enum machine_mode mode)
2979 +{
2980 +  switch (mode)
2981 +    {
2982 +    case QImode:
2983 +      return 127;
2984 +
2985 +    case HImode:
2986 +      return 255;
2987 +
2988 +    case SImode:
2989 +    case SFmode:
2990 +      return 511;
2991 +
2992 +    case DImode:
2993 +      return 255;
2994 +
2995 +    default:
2996 +      return 0;
2997 +    }
2998 +}
2999 +
3000 +/* Returns 1 if X is a valid base register.  STRICT is 1 if only hard
3001 +   registers should be accepted.  Accept either REG or SUBREG where a
3002 +   register is valid.  */
3003 +
3004 +static bool
3005 +ubicom32_is_base_reg (rtx x, int strict)
3006 +{
3007 +  if ((REG_P (x) && ubicom32_regno_ok_for_base_p (REGNO (x), strict))
3008 +      || (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x))
3009 +         && ubicom32_regno_ok_for_base_p (REGNO (SUBREG_REG (x)), strict)))
3010 +    return true;
3011 +
3012 +  return false;
3013 +}
3014 +
3015 +static bool
3016 +ubicom32_cannot_force_const_mem (rtx x ATTRIBUTE_UNUSED)
3017 +{
3018 +  return TARGET_FDPIC;
3019 +}
3020 +
3021 +/* Determine if X is a legitimate constant.  */
3022 +
3023 +bool
3024 +ubicom32_legitimate_constant_p (rtx x)
3025 +{
3026 +  /* Among its other duties, LEGITIMATE_CONSTANT_P decides whether
3027 +     a constant can be entered into reg_equiv_constant[].  If we return true,
3028 +     reload can create new instances of the constant whenever it likes.
3029 +
3030 +     The idea is therefore to accept as many constants as possible (to give
3031 +     reload more freedom) while rejecting constants that can only be created
3032 +     at certain times.  In particular, anything with a symbolic component will
3033 +     require use of the pseudo FDPIC register, which is only available before
3034 +     reload.  */
3035 +  if (TARGET_FDPIC)
3036 +    {
3037 +      if (GET_CODE (x) == SYMBOL_REF
3038 +         || (GET_CODE (x) == CONST
3039 +             && GET_CODE (XEXP (x, 0)) == PLUS
3040 +             && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF)
3041 +         || CONSTANT_ADDRESS_P (x))
3042 +       return false;
3043 +
3044 +      return true;
3045 +    }
3046 +
3047 +  /* For non-PIC code anything goes!  */
3048 +  return true;
3049 +}
3050 +
3051 +/* Address validation.  */
3052 +
3053 +bool
3054 +ubicom32_legitimate_address_p (enum machine_mode mode, rtx x, int strict)
3055 +{
3056 +  if (TARGET_DEBUG_ADDRESS)
3057 +    {
3058 +      fprintf (stderr, "\n==> GO_IF_LEGITIMATE_ADDRESS%s\n",
3059 +              (strict) ? " (STRICT)" : "");
3060 +      debug_rtx (x);
3061 +    }
3062 +
3063 +  if (CONSTANT_ADDRESS_P (x))
3064 +    return false;
3065 +
3066 +  if (ubicom32_is_base_reg (x, strict))
3067 +    return true;
3068 +
3069 +  if ((GET_CODE (x) == POST_INC
3070 +       || GET_CODE (x) == PRE_INC
3071 +       || GET_CODE (x) == POST_DEC
3072 +       || GET_CODE (x) == PRE_DEC)
3073 +      && REG_P (XEXP (x, 0))
3074 +      && ubicom32_is_base_reg (XEXP (x, 0), strict)
3075 +      && mode != DImode)
3076 +    return true;
3077 +
3078 +  if ((GET_CODE (x) == PRE_MODIFY || GET_CODE (x) == POST_MODIFY)
3079 +      && ubicom32_is_base_reg (XEXP (x, 0), strict)
3080 +      && GET_CODE (XEXP (x, 1)) == PLUS
3081 +      && rtx_equal_p (XEXP (x, 0), XEXP (XEXP (x, 1), 0))
3082 +      && CONST_INT_P (XEXP (XEXP (x, 1), 1))
3083 +      && mode != DImode)
3084 +    {
3085 +      HOST_WIDE_INT disp = INTVAL (XEXP (XEXP (x, 1), 1));
3086 +      switch (mode)
3087 +       {
3088 +       case QImode:
3089 +         return disp >= -8 && disp <= 7;
3090 +
3091 +       case HImode:
3092 +         return disp >= -16 && disp <= 14 && ! (disp & 1);
3093 +
3094 +       case SImode:
3095 +         return disp >= -32 && disp <= 28 && ! (disp & 3);
3096 +
3097 +       default:
3098 +         return false;
3099 +       }
3100 +    }
3101 +
3102 +  /* Accept base + index * scale.  */
3103 +  if (GET_CODE (x) == PLUS
3104 +      && ubicom32_is_base_reg (XEXP (x, 0), strict)
3105 +      && ubicom32_is_index_expr (mode, XEXP (x, 1), strict))
3106 +    return true;
3107 +
3108 +  /* Accept index * scale + base.  */
3109 +  if (GET_CODE (x) == PLUS
3110 +      && ubicom32_is_base_reg (XEXP (x, 1), strict)
3111 +      && ubicom32_is_index_expr (mode, XEXP (x, 0), strict))
3112 +    return true;
3113 +
3114 +  if (! TARGET_FDPIC)
3115 +    {
3116 +      /* Accept (lo_sum (reg) (symbol_ref)) that can be used as a mem+7bits
3117 +        displacement operand:
3118 +
3119 +        moveai a1, #%hi(SYM)
3120 +        move.4 d3, %lo(SYM)(a1)  */
3121 +      if (GET_CODE (x) == LO_SUM
3122 +         && ubicom32_is_base_reg (XEXP (x, 0), strict)
3123 +         && (GET_CODE (XEXP (x, 1)) == SYMBOL_REF
3124 +             || GET_CODE (XEXP (x, 1)) == LABEL_REF /* FIXME: wrong */)
3125 +         && mode != DImode)
3126 +       return true;
3127 +    }
3128 +
3129 +  if (TARGET_DEBUG_ADDRESS)
3130 +    fprintf (stderr, "\nNot a legitimate address.\n");
3131 +
3132 +  return false;
3133 +}
3134 +
3135 +rtx
3136 +ubicom32_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3137 +                            enum machine_mode mode)
3138 +{
3139 +  if (mode == BLKmode)
3140 +    return NULL_RTX;
3141 +
3142 +  if (GET_CODE (x) == PLUS
3143 +      && REG_P (XEXP (x, 0))
3144 +      && ! REGNO_PTR_FRAME_P (REGNO (XEXP (x, 0)))
3145 +      && CONST_INT_P (XEXP (x, 1))
3146 +      && ! ubicom32_is_valid_offset (mode, INTVAL (XEXP (x, 1))))
3147 +    {
3148 +      rtx base;
3149 +      rtx plus;
3150 +      rtx new_rtx;
3151 +      HOST_WIDE_INT val = INTVAL (XEXP (x, 1));
3152 +      HOST_WIDE_INT low = val & ubicom32_get_valid_offset_mask (mode);
3153 +      HOST_WIDE_INT high = val ^ low;
3154 +
3155 +      if (val < 0)
3156 +       return NULL_RTX;
3157 +
3158 +      if (! low)
3159 +       return NULL_RTX;
3160 +
3161 +      /* Reload the high part into a base reg; leave the low part
3162 +        in the mem directly.  */
3163 +      base = XEXP (x, 0);
3164 +      if (! ubicom32_is_base_reg (base, 0))
3165 +       base = copy_to_mode_reg (Pmode, base);
3166 +
3167 +      plus = expand_simple_binop (Pmode, PLUS,
3168 +                                 gen_int_mode (high, Pmode),
3169 +                                 base, NULL, 0, OPTAB_WIDEN);
3170 +      new_rtx = plus_constant (plus, low);
3171 +
3172 +      return new_rtx;
3173 +    }
3174 +
3175 +  return NULL_RTX;
3176 +}
3177 +
3178 +/* Try a machine-dependent way of reloading an illegitimate address AD
3179 +   operand.  If we find one, push the reload and and return the new address.
3180 +
3181 +   MODE is the mode of the enclosing MEM.  OPNUM is the operand number
3182 +   and TYPE is the reload type of the current reload.  */
3183 +
3184 +rtx
3185 +ubicom32_legitimize_reload_address (rtx ad, enum machine_mode mode,
3186 +                                   int opnum, int type)
3187 +{
3188 +  /* Is this an address that we've already fixed up?  If it is then
3189 +     recognize it and move on.  */
3190 +  if (GET_CODE (ad) == PLUS
3191 +      && GET_CODE (XEXP (ad, 0)) == PLUS
3192 +      && REG_P (XEXP (XEXP (ad, 0), 0))
3193 +      && CONST_INT_P (XEXP (XEXP (ad, 0), 1))
3194 +      && CONST_INT_P (XEXP (ad, 1)))
3195 +    {
3196 +      push_reload (XEXP (ad, 0), NULL_RTX, &XEXP (ad, 0), NULL,
3197 +                  BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3198 +                  opnum, (enum reload_type) type);
3199 +      return ad;
3200 +    }
3201 +
3202 +  /* Have we got an address where the offset is simply out of range?  If
3203 +     yes then reload the range as a high part and smaller offset.  */
3204 +  if (GET_CODE (ad) == PLUS
3205 +      && REG_P (XEXP (ad, 0))
3206 +      && REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER
3207 +      && REGNO_OK_FOR_BASE_P (REGNO (XEXP (ad, 0)))
3208 +      && CONST_INT_P (XEXP (ad, 1))
3209 +      && ! ubicom32_is_valid_offset (mode, INTVAL (XEXP (ad, 1))))
3210 +    {
3211 +      rtx temp;
3212 +      rtx new_rtx;
3213 +
3214 +      HOST_WIDE_INT val = INTVAL (XEXP (ad, 1));
3215 +      HOST_WIDE_INT low = val & ubicom32_get_valid_offset_mask (mode);
3216 +      HOST_WIDE_INT high = val ^ low;
3217 +
3218 +      /* Reload the high part into a base reg; leave the low part
3219 +        in the mem directly.  */
3220 +      temp = gen_rtx_PLUS (Pmode, XEXP (ad, 0), GEN_INT (high));
3221 +      new_rtx = gen_rtx_PLUS (Pmode, temp, GEN_INT (low));
3222 +
3223 +      push_reload (XEXP (new_rtx, 0), NULL_RTX, &XEXP (new_rtx, 0), NULL,
3224 +                  BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3225 +                  opnum, (enum reload_type) type);
3226 +      return new_rtx;
3227 +    }
3228 +
3229 +  /* If we're presented with an pre/post inc/dec then we must force this
3230 +     to be done in an address register.  The register allocator should
3231 +     work this out for itself but at times ends up trying to use the wrong
3232 +     class.  If we get the wrong class then reload will end up generating
3233 +     at least 3 instructions whereas this way we can hopefully keep it to
3234 +     just 2.  */
3235 +  if ((GET_CODE (ad) == POST_INC
3236 +       || GET_CODE (ad) == PRE_INC
3237 +       || GET_CODE (ad) == POST_DEC
3238 +       || GET_CODE (ad) == PRE_DEC)
3239 +      && REG_P (XEXP (ad, 0))
3240 +      && REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER
3241 +      && ! REGNO_OK_FOR_BASE_P (REGNO (XEXP (ad, 0))))
3242 +    {
3243 +      push_reload (XEXP (ad, 0), XEXP (ad, 0), &XEXP (ad, 0), &XEXP (ad, 0),
3244 +                  BASE_REG_CLASS, GET_MODE (XEXP (ad, 0)), GET_MODE (XEXP (ad, 0)), 0, 0,
3245 +                  opnum, RELOAD_OTHER);
3246 +      return ad;
3247 +    }
3248 +
3249 +  return NULL_RTX;
3250 +}
3251 +
3252 +/* Compute a (partial) cost for rtx X.  Return true if the complete
3253 +   cost has been computed, and false if subexpressions should be
3254 +   scanned.  In either case, *TOTAL contains the cost result.  */
3255 +
3256 +static bool
3257 +ubicom32_rtx_costs (rtx x, int code, int outer_code, int *total,
3258 +                   bool speed ATTRIBUTE_UNUSED)
3259 +{
3260 +  enum machine_mode mode = GET_MODE (x);
3261 +
3262 +  switch (code)
3263 +    {
3264 +    case CONST_INT:
3265 +      /* Very short constants often fold into instructions so
3266 +         we pretend that they don't cost anything!  This is
3267 +        really important as regards zero values as otherwise
3268 +        the compiler has a nasty habit of wanting to reuse
3269 +        zeroes that are in regs but that tends to pessimize
3270 +        the code.  */
3271 +      if (satisfies_constraint_I (x))
3272 +       {
3273 +         *total = 0;
3274 +         return true;
3275 +       }
3276 +
3277 +      /* Bit clearing costs nothing  */
3278 +      if (outer_code == AND
3279 +         && exact_log2 (~INTVAL (x)) != -1)
3280 +       {
3281 +         *total = 0;
3282 +         return true;
3283 +       }
3284 +
3285 +      /* Masking the lower set of bits costs nothing.  */
3286 +      if (outer_code == AND
3287 +         && exact_log2 (INTVAL (x) + 1) != -1)
3288 +       {
3289 +         *total = 0;
3290 +         return true;
3291 +       }
3292 +
3293 +      /* Bit setting costs nothing.  */
3294 +      if (outer_code == IOR
3295 +         && exact_log2 (INTVAL (x)) != -1)
3296 +       {
3297 +         *total = 0;
3298 +         return true;
3299 +       }
3300 +
3301 +      /* Larger constants that can be loaded via movei aren't too
3302 +         bad.  If we're just doing a set they cost nothing extra.  */
3303 +      if (satisfies_constraint_N (x))
3304 +       {
3305 +         if (mode == DImode)
3306 +           *total = COSTS_N_INSNS (2);
3307 +         else
3308 +           *total = COSTS_N_INSNS (1);
3309 +         return true;
3310 +       }
3311 +
3312 +      if (mode == DImode)
3313 +       *total = COSTS_N_INSNS (5);
3314 +      else
3315 +        *total = COSTS_N_INSNS (3);
3316 +      return true;
3317 +
3318 +    case CONST_DOUBLE:
3319 +      /* We don't optimize CONST_DOUBLEs well nor do we relax them well,
3320 +        so their cost is very high.  */
3321 +      *total = COSTS_N_INSNS (6);
3322 +      return true;
3323 +
3324 +    case CONST:
3325 +    case SYMBOL_REF:
3326 +    case MEM:
3327 +      *total = 0;
3328 +      return true;
3329 +
3330 +    case IF_THEN_ELSE:
3331 +      *total = COSTS_N_INSNS (1);
3332 +      return true;
3333 +
3334 +    case LABEL_REF:
3335 +    case HIGH:
3336 +    case LO_SUM:
3337 +    case BSWAP:
3338 +    case PLUS:
3339 +    case MINUS:
3340 +    case AND:
3341 +    case IOR:
3342 +    case XOR:
3343 +    case ASHIFT:
3344 +    case ASHIFTRT:
3345 +    case LSHIFTRT:
3346 +    case NEG:
3347 +    case NOT:
3348 +    case SIGN_EXTEND:
3349 +    case ZERO_EXTEND:
3350 +    case ZERO_EXTRACT:
3351 +      if (outer_code == SET)
3352 +       {
3353 +         if (mode == DImode)
3354 +           *total = COSTS_N_INSNS (2);
3355 +         else
3356 +           *total = COSTS_N_INSNS (1);
3357 +       }
3358 +      return true;
3359 +
3360 +    case COMPARE:
3361 +      if (outer_code == SET)
3362 +       {
3363 +         if (GET_MODE (XEXP (x, 0)) == DImode
3364 +             || GET_MODE (XEXP (x, 1)) == DImode)
3365 +           *total = COSTS_N_INSNS (2);
3366 +         else
3367 +           *total = COSTS_N_INSNS (1);
3368 +       }
3369 +      return true;
3370 +
3371 +    case UMOD:
3372 +    case UDIV:
3373 +    case MOD:
3374 +    case DIV:
3375 +      if (outer_code == SET)
3376 +       {
3377 +         if (mode == DImode)
3378 +           *total = COSTS_N_INSNS (600);
3379 +         else
3380 +           *total = COSTS_N_INSNS (200);
3381 +       }
3382 +      return true;
3383 +
3384 +    case MULT:
3385 +      if (outer_code == SET)
3386 +       {
3387 +         if (! ubicom32_v4)
3388 +           {
3389 +             if (mode == DImode)
3390 +               *total = COSTS_N_INSNS (15);
3391 +             else
3392 +               *total = COSTS_N_INSNS (5);
3393 +           }
3394 +         else
3395 +           {
3396 +             if (mode == DImode)
3397 +               *total = COSTS_N_INSNS (6);
3398 +             else
3399 +               *total = COSTS_N_INSNS (2);
3400 +           }
3401 +       }
3402 +      return true;
3403 +
3404 +    case UNSPEC:
3405 +      if (XINT (x, 1) == UNSPEC_FDPIC_GOT
3406 +         || XINT (x, 1) == UNSPEC_FDPIC_GOT_FUNCDESC)
3407 +       *total = 0;
3408 +      return true;
3409 +
3410 +    default:
3411 +      return false;
3412 +    }
3413 +}
3414 +
3415 +/* Return 1 if ADDR can have different meanings depending on the machine
3416 +   mode of the memory reference it is used for or if the address is
3417 +   valid for some modes but not others.
3418 +
3419 +   Autoincrement and autodecrement addresses typically have
3420 +   mode-dependent effects because the amount of the increment or
3421 +   decrement is the size of the operand being addressed.  Some machines
3422 +   have other mode-dependent addresses. Many RISC machines have no
3423 +   mode-dependent addresses.
3424 +
3425 +   You may assume that ADDR is a valid address for the machine.  */
3426 +
3427 +int
3428 +ubicom32_mode_dependent_address_p (rtx addr)
3429 +{
3430 +  if (GET_CODE (addr) == POST_INC
3431 +      || GET_CODE (addr) == PRE_INC
3432 +      || GET_CODE (addr) == POST_DEC
3433 +      || GET_CODE (addr) == PRE_DEC
3434 +      || GET_CODE (addr) == POST_MODIFY
3435 +      || GET_CODE (addr) == PRE_MODIFY)
3436 +    return 1;
3437 +
3438 +  return 0;
3439 +}
3440 +
3441 +static void
3442 +ubicom32_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
3443 +{
3444 +  fprintf (file, "/* frame/pretend: %ld/%d save_regs: %d out_args: %d  %s */\n",
3445 +          get_frame_size (), crtl->args.pretend_args_size,
3446 +          save_regs_size, crtl->outgoing_args_size,
3447 +          current_function_is_leaf ? "leaf" : "nonleaf");
3448 +}
3449 +
3450 +static void
3451 +ubicom32_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
3452 +                           HOST_WIDE_INT size ATTRIBUTE_UNUSED)
3453 +{
3454 +  ubicom32_reorg_completed = 0;
3455 +}
3456 +
3457 +static void
3458 +ubicom32_machine_dependent_reorg (void)
3459 +{
3460 +#if 0 /* Commenting out this optimization until it is fixed */
3461 +  if (optimize)
3462 +    {
3463 +      compute_bb_for_insn ();
3464 +
3465 +      /* Do a very simple CSE pass over just the hard registers.  */
3466 +      reload_cse_regs (get_insns ());
3467 +
3468 +      /* Reload_cse_regs can eliminate potentially-trapping MEMs.
3469 +        Remove any EH edges associated with them.  */
3470 +      if (flag_non_call_exceptions)
3471 +       purge_all_dead_edges ();
3472 +    }
3473 +#endif
3474 +  ubicom32_reorg_completed = 1;
3475 +}
3476 +
3477 +void
3478 +ubicom32_output_cond_jump (rtx insn, rtx cond, rtx target)
3479 +{
3480 +  rtx note;
3481 +  int mostly_false_jump;
3482 +  rtx xoperands[2];
3483 +  rtx cc_reg;
3484 +
3485 +  note = find_reg_note (insn, REG_BR_PROB, 0);
3486 +  mostly_false_jump = !note || (INTVAL (XEXP (note, 0))
3487 +                               <= REG_BR_PROB_BASE / 2);
3488 +
3489 +  xoperands[0] = target;
3490 +  xoperands[1] = cond;
3491 +  cc_reg = XEXP (cond, 0);
3492 +
3493 +  if (GET_MODE (cc_reg) == CCWmode
3494 +      || GET_MODE (cc_reg) == CCWZmode
3495 +      || GET_MODE (cc_reg) == CCWZNmode)
3496 +    {
3497 +      if (mostly_false_jump)
3498 +        output_asm_insn ("jmp%b1.w.f\t%0", xoperands);
3499 +      else
3500 +        output_asm_insn ("jmp%b1.w.t\t%0", xoperands);
3501 +      return;
3502 +    }
3503 +
3504 +  if (GET_MODE (cc_reg) == CCSmode
3505 +      || GET_MODE (cc_reg) == CCSZmode
3506 +      || GET_MODE (cc_reg) == CCSZNmode)
3507 +    {
3508 +      if (mostly_false_jump)
3509 +        output_asm_insn ("jmp%b1.s.f\t%0", xoperands);
3510 +      else
3511 +        output_asm_insn ("jmp%b1.s.t\t%0", xoperands);
3512 +      return;
3513 +    }
3514 +
3515 +  abort ();
3516 +}
3517 +
3518 +/* Return non-zero if FUNC is a naked function.  */
3519 +
3520 +static int
3521 +ubicom32_naked_function_p (void)
3522 +{
3523 +  return lookup_attribute ("naked", DECL_ATTRIBUTES (current_function_decl)) != NULL_TREE;
3524 +}
3525 +
3526 +/* Return an RTX indicating where the return address to the
3527 +   calling function can be found.  */
3528 +rtx
3529 +ubicom32_return_addr_rtx (int count, rtx frame ATTRIBUTE_UNUSED)
3530 +{
3531 +  if (count != 0)
3532 +    return NULL_RTX;
3533 +
3534 +  return get_hard_reg_initial_val (Pmode, LINK_REGNO);
3535 +}
3536 +
3537 +/*
3538 + * ubicom32_readonly_data_section: This routtine handles code
3539 + * at the start of readonly data sections
3540 + */
3541 +static void
3542 +ubicom32_readonly_data_section (const void *data ATTRIBUTE_UNUSED)
3543 +{
3544 +  static int num = 0;
3545 +  if (in_section == readonly_data_section){
3546 +    fprintf (asm_out_file, "%s", DATA_SECTION_ASM_OP);
3547 +    if (flag_data_sections){
3548 +      fprintf (asm_out_file, ".rodata%d", num);
3549 +      fprintf (asm_out_file, ",\"a\"");
3550 +    }
3551 +    fprintf (asm_out_file, "\n");
3552 +  }
3553 +  num++;
3554 +}
3555 +
3556 +/*
3557 + * ubicom32_text_section: not in readonly section
3558 + */
3559 +static void
3560 +ubicom32_text_section(const void *data ATTRIBUTE_UNUSED)
3561 +{
3562 +  fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
3563 +}
3564 +
3565 +/*
3566 + * ubicom32_data_section: not in readonly section
3567 + */
3568 +static void
3569 +ubicom32_data_section(const void *data ATTRIBUTE_UNUSED)
3570 +{
3571 +  fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
3572 +}
3573 +
3574 +/*
3575 + * ubicom32_asm_init_sections: This routine implements special
3576 + * section handling
3577 + */
3578 +static void
3579 +ubicom32_asm_init_sections(void)
3580 +{
3581 +  text_section = get_unnamed_section(SECTION_CODE, ubicom32_text_section, NULL);
3582 +
3583 +  data_section = get_unnamed_section(SECTION_WRITE, ubicom32_data_section, NULL);
3584 +
3585 +  readonly_data_section = get_unnamed_section(0, ubicom32_readonly_data_section, NULL);
3586 +}
3587 +
3588 +/*
3589 + * ubicom32_profiler:  This routine would call
3590 + * mcount to support prof and gprof if mcount
3591 + * was supported. Currently, do nothing.
3592 + */
3593 +void
3594 +ubicom32_profiler(void)
3595 +{
3596 +}
3597 +
3598 +/* Initialise the builtin functions.  Start by initialising
3599 +   descriptions of different types of functions (e.g., void fn(int),
3600 +   int fn(void)), and then use these to define the builtins. */
3601 +static void
3602 +ubicom32_init_builtins (void)
3603 +{
3604 +  tree endlink;
3605 +  tree short_unsigned_endlink;
3606 +  tree unsigned_endlink;
3607 +  tree short_unsigned_ftype_short_unsigned;
3608 +  tree unsigned_ftype_unsigned;
3609 +
3610 +  endlink = void_list_node;
3611 +
3612 +  short_unsigned_endlink
3613 +    = tree_cons (NULL_TREE, short_unsigned_type_node, endlink);
3614 +
3615 +  unsigned_endlink
3616 +    = tree_cons (NULL_TREE, unsigned_type_node, endlink);
3617 +
3618 +  short_unsigned_ftype_short_unsigned
3619 +    = build_function_type (short_unsigned_type_node, short_unsigned_endlink);
3620 +
3621 +  unsigned_ftype_unsigned
3622 +    = build_function_type (unsigned_type_node, unsigned_endlink);
3623 +
3624 +  /* Initialise the byte swap function. */
3625 +  add_builtin_function ("__builtin_ubicom32_swapb_2",
3626 +                       short_unsigned_ftype_short_unsigned,
3627 +                       UBICOM32_BUILTIN_UBICOM32_SWAPB_2,
3628 +                       BUILT_IN_MD, NULL,
3629 +                       NULL_TREE);
3630 +
3631 +  /* Initialise the byte swap function. */
3632 +  add_builtin_function ("__builtin_ubicom32_swapb_4",
3633 +                       unsigned_ftype_unsigned,
3634 +                       UBICOM32_BUILTIN_UBICOM32_SWAPB_4,
3635 +                       BUILT_IN_MD, NULL,
3636 +                       NULL_TREE);
3637 +}
3638 +
3639 +/* Given a builtin function taking 2 operands (i.e., target + source),
3640 +   emit the RTL for the underlying instruction. */
3641 +static rtx
3642 +ubicom32_expand_builtin_2op (enum insn_code icode, tree arglist, rtx target)
3643 +{
3644 +  tree arg0;
3645 +  rtx op0, pat;
3646 +  enum machine_mode tmode, mode0;
3647 +
3648 +  /* Grab the incoming argument and emit its RTL. */
3649 +  arg0 = TREE_VALUE (arglist);
3650 +  op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
3651 +
3652 +  /* Determine the modes of the instruction operands. */
3653 +  tmode = insn_data[icode].operand[0].mode;
3654 +  mode0 = insn_data[icode].operand[1].mode;
3655 +
3656 +  /* Ensure that the incoming argument RTL is in a register of the
3657 +     correct mode. */
3658 +  if (!(*insn_data[icode].operand[1].predicate) (op0, mode0))
3659 +    op0 = copy_to_mode_reg (mode0, op0);
3660 +
3661 +  /* If there isn't a suitable target, emit a target register. */
3662 +  if (target == 0
3663 +      || GET_MODE (target) != tmode
3664 +      || !(*insn_data[icode].operand[0].predicate) (target, tmode))
3665 +    target = gen_reg_rtx (tmode);
3666 +
3667 +  /* Emit and return the new instruction. */
3668 +  pat = GEN_FCN (icode) (target, op0);
3669 +  if (!pat)
3670 +    return 0;
3671 +  emit_insn (pat);
3672 +
3673 +  return target;
3674 +}
3675 +
3676 +/* Expand a call to a builtin function. */
3677 +static rtx
3678 +ubicom32_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
3679 +                        enum machine_mode mode ATTRIBUTE_UNUSED,
3680 +                        int ignore ATTRIBUTE_UNUSED)
3681 +{
3682 +  tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
3683 +  tree arglist = CALL_EXPR_ARGS(exp);
3684 +  int fcode = DECL_FUNCTION_CODE (fndecl);
3685 +
3686 +  switch (fcode)
3687 +    {
3688 +    case UBICOM32_BUILTIN_UBICOM32_SWAPB_2:
3689 +      return ubicom32_expand_builtin_2op (CODE_FOR_bswaphi, arglist, target);
3690 +
3691 +    case UBICOM32_BUILTIN_UBICOM32_SWAPB_4:
3692 +      return ubicom32_expand_builtin_2op (CODE_FOR_bswapsi, arglist, target);
3693 +
3694 +    default:
3695 +      gcc_unreachable();
3696 +    }
3697 +
3698 +  /* Should really do something sensible here.  */
3699 +  return NULL_RTX;
3700 +}
3701 +
3702 +/* Fold any constant argument for a swapb.2 instruction.  */
3703 +static tree
3704 +ubicom32_fold_builtin_ubicom32_swapb_2 (tree fndecl, tree arglist)
3705 +{
3706 +  tree arg0;
3707 +
3708 +  arg0 = TREE_VALUE (arglist);
3709 +
3710 +  /* Optimize constant value.  */
3711 +  if (TREE_CODE (arg0) == INTEGER_CST)
3712 +    {
3713 +      HOST_WIDE_INT v;
3714 +      HOST_WIDE_INT res;
3715 +
3716 +      v = TREE_INT_CST_LOW (arg0);
3717 +      res = ((v >> 8) & 0xff)
3718 +            | ((v & 0xff) << 8);
3719 +
3720 +      return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), res);
3721 +    }
3722 +
3723 +  return NULL_TREE;
3724 +}
3725 +
3726 +/* Fold any constant argument for a swapb.4 instruction.  */
3727 +static tree
3728 +ubicom32_fold_builtin_ubicom32_swapb_4 (tree fndecl, tree arglist)
3729 +{
3730 +  tree arg0;
3731 +
3732 +  arg0 = TREE_VALUE (arglist);
3733 +
3734 +  /* Optimize constant value.  */
3735 +  if (TREE_CODE (arg0) == INTEGER_CST)
3736 +    {
3737 +      unsigned HOST_WIDE_INT v;
3738 +      unsigned HOST_WIDE_INT res;
3739 +
3740 +      v = TREE_INT_CST_LOW (arg0);
3741 +      res = ((v >> 24) & 0xff)
3742 +            | (((v >> 16) & 0xff) << 8)
3743 +            | (((v >> 8) & 0xff) << 16)
3744 +            | ((v & 0xff) << 24);
3745 +
3746 +      return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), res, 0);
3747 +    }
3748 +
3749 +  return NULL_TREE;
3750 +}
3751 +
3752 +/* Fold any constant arguments for builtin functions.  */
3753 +static tree
3754 +ubicom32_fold_builtin (tree fndecl, tree arglist, bool ignore ATTRIBUTE_UNUSED)
3755 +{
3756 +  switch (DECL_FUNCTION_CODE (fndecl))
3757 +    {
3758 +    case UBICOM32_BUILTIN_UBICOM32_SWAPB_2:
3759 +      return ubicom32_fold_builtin_ubicom32_swapb_2 (fndecl, arglist);
3760 +
3761 +    case UBICOM32_BUILTIN_UBICOM32_SWAPB_4:
3762 +      return ubicom32_fold_builtin_ubicom32_swapb_4 (fndecl, arglist);
3763 +
3764 +    default:
3765 +      return NULL;
3766 +    }
3767 +}
3768 +
3769 +/* Implementation of TARGET_ASM_INTEGER.  When using FD-PIC, we need to
3770 +   tell the assembler to generate pointers to function descriptors in
3771 +   some cases.  */
3772 +static bool
3773 +ubicom32_assemble_integer (rtx value, unsigned int size, int aligned_p)
3774 +{
3775 +  if (TARGET_FDPIC && size == UNITS_PER_WORD)
3776 +    {
3777 +      if (GET_CODE (value) == SYMBOL_REF
3778 +         && SYMBOL_REF_FUNCTION_P (value))
3779 +       {
3780 +         fputs ("\t.picptr\t%funcdesc(", asm_out_file);
3781 +         output_addr_const (asm_out_file, value);
3782 +         fputs (")\n", asm_out_file);
3783 +         return true;
3784 +       }
3785 +
3786 +      if (!aligned_p)
3787 +       {
3788 +         /* We've set the unaligned SI op to NULL, so we always have to
3789 +            handle the unaligned case here.  */
3790 +         assemble_integer_with_op ("\t.4byte\t", value);
3791 +         return true;
3792 +       }
3793 +    }
3794 +
3795 +  return default_assemble_integer (value, size, aligned_p);
3796 +}
3797 +
3798 +/* If the constant I can be constructed by shifting a source-1 immediate
3799 +   by a constant number of bits then return the bit count.  If not
3800 +   return 0.  */
3801 +
3802 +int
3803 +ubicom32_shiftable_const_int (int i)
3804 +{
3805 +  int shift = 0;
3806 +
3807 +  /* Note that any constant that can be represented as an immediate to
3808 +     a movei instruction is automatically ignored here in the interests
3809 +     of the clarity of the output asm code.  */
3810 +  if (i >= -32768 && i <= 32767)
3811 +    return 0;
3812 +
3813 +  /* Find the number of trailing zeroes.  We could use __builtin_ctz
3814 +     here but it's not obvious if this is supported on all build
3815 +     compilers so we err on the side of caution.  */
3816 +  if ((i & 0xffff) == 0)
3817 +    {
3818 +      shift += 16;
3819 +      i >>= 16;
3820 +    }
3821 +
3822 +  if ((i & 0xff) == 0)
3823 +    {
3824 +      shift += 8;
3825 +      i >>= 8;
3826 +    }
3827 +
3828 +  if ((i & 0xf) == 0)
3829 +    {
3830 +      shift += 4;
3831 +      i >>= 4;
3832 +    }
3833 +
3834 +  if ((i & 0x3) == 0)
3835 +    {
3836 +      shift += 2;
3837 +      i >>= 2;
3838 +    }
3839 +
3840 +  if ((i & 0x1) == 0)
3841 +    {
3842 +      shift += 1;
3843 +      i >>= 1;
3844 +    }
3845 +
3846 +  if (i >= -128 && i <= 127)
3847 +    return shift;
3848 +
3849 +  return 0;
3850 +}
3851 +
3852 --- /dev/null
3853 +++ b/gcc/config/ubicom32/ubicom32.h
3854 @@ -0,0 +1,1564 @@
3855 +/* Definitions of target machine for Ubicom32
3856 +
3857 +   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3858 +   2009 Free Software Foundation, Inc.
3859 +   Contributed by Ubicom, Inc.
3860 +
3861 +   This file is part of GCC.
3862 +
3863 +   GCC is free software; you can redistribute it and/or modify it
3864 +   under the terms of the GNU General Public License as published
3865 +   by the Free Software Foundation; either version 3, or (at your
3866 +   option) any later version.
3867 +
3868 +   GCC is distributed in the hope that it will be useful, but WITHOUT
3869 +   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
3870 +   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
3871 +   License for more details.
3872 +
3873 +   You should have received a copy of the GNU General Public License
3874 +   along with GCC; see the file COPYING3.  If not see
3875 +   <http://www.gnu.org/licenses/>.  */
3876 +
3877 +\f
3878 +
3879 +#define OBJECT_FORMAT_ELF
3880 +
3881 +/* Run-time target specifications. */
3882 +
3883 +/* Target CPU builtins.  */
3884 +#define TARGET_CPU_CPP_BUILTINS()                      \
3885 +  do                                                   \
3886 +    {                                                  \
3887 +      builtin_define_std ("__UBICOM32__");             \
3888 +      builtin_define_std ("__ubicom32__");             \
3889 +                                                       \
3890 +      if (TARGET_FDPIC)                                        \
3891 +       {                                               \
3892 +         builtin_define ("__UBICOM32_FDPIC__");        \
3893 +         builtin_define ("__FDPIC__");                 \
3894 +       }                                               \
3895 +    }                                                  \
3896 +  while (0)
3897 +
3898 +#ifndef TARGET_DEFAULT
3899 +#define TARGET_DEFAULT 0
3900 +#endif
3901 +
3902 +extern int ubicom32_case_values_threshold;
3903 +
3904 +/* Nonzero if this chip supports the Ubicom32 v3 ISA.  */
3905 +extern int ubicom32_v3;
3906 +
3907 +/* Nonzero if this chip supports the Ubicom32 v4 ISA.  */
3908 +extern int ubicom32_v4;
3909 +
3910 +extern int ubicom32_stack_size;
3911 +
3912 +/* Flag for whether we can use calli instead of ret in returns.  */
3913 +extern int ubicom32_can_use_calli_to_ret;
3914 +
3915 +/* This macro is a C statement to print on `stderr' a string describing the
3916 +   particular machine description choice.  Every machine description should
3917 +   define `TARGET_VERSION'. */
3918 +#define TARGET_VERSION fprintf (stderr, " (UBICOM32)");
3919 +
3920 +/* We don't need a frame pointer to debug things.  Doing this means
3921 +   that gcc can turn on -fomit-frame-pointer when '-O' is specified.  */
3922 +#define CAN_DEBUG_WITHOUT_FP
3923 +
3924 +/* We need to handle processor-specific options.  */
3925 +#define OVERRIDE_OPTIONS ubicom32_override_options ()
3926 +
3927 +#define OPTIMIZATION_OPTIONS(LEVEL, SIZE) \
3928 +  ubicom32_optimization_options (LEVEL, SIZE)
3929 +
3930 +/* For Ubicom32 the least significant bit has the lowest bit number
3931 +   so we define this to be 0.  */
3932 +#define BITS_BIG_ENDIAN 0
3933 +
3934 +/* For Ubicom32 the most significant byte in a word has the lowest
3935 +   number.  */
3936 +#define BYTES_BIG_ENDIAN 1
3937 +
3938 +/* For Ubicom32, in a multiword object, the most signifant word has the
3939 +   lowest number.  */
3940 +#define WORDS_BIG_ENDIAN 1
3941 +
3942 +/* Ubicom32 has 8 bits per byte.  */
3943 +#define BITS_PER_UNIT 8
3944 +
3945 +/* Ubicom32 has 32 bits per word.  */
3946 +#define BITS_PER_WORD 32
3947 +
3948 +/* Width of a word, in units (bytes).  */
3949 +#define UNITS_PER_WORD 4
3950 +
3951 +/* Width of a pointer, in bits.  */
3952 +#define POINTER_SIZE 32
3953 +
3954 +/* Alias for pointers.  Ubicom32 is a 32-bit architecture so we use
3955 +   SImode.  */
3956 +#define Pmode SImode
3957 +
3958 +/* Normal alignment required for function parameters on the stack, in
3959 +   bits.  */
3960 +#define PARM_BOUNDARY 32
3961 +
3962 +/* We need to maintain the stack on a 32-bit boundary.  */
3963 +#define STACK_BOUNDARY 32
3964 +
3965 +/* Alignment required for a function entry point, in bits.  */
3966 +#define FUNCTION_BOUNDARY 32
3967 +
3968 +/* Alias for the machine mode used for memory references to functions being
3969 +   called, in `call' RTL expressions.  We use byte-oriented addresses
3970 +   here.  */
3971 +#define FUNCTION_MODE QImode
3972 +
3973 +/* Biggest alignment that any data type can require on this machine,
3974 +   in bits.  */
3975 +#define BIGGEST_ALIGNMENT 32
3976 +
3977 +/* this default to BIGGEST_ALIGNMENT unless defined       */
3978 +/* ART: What's the correct value here? Default is (((unsigned int)1<<28)*8)*/
3979 +#undef MAX_OFILE_ALIGNMENT
3980 +#define MAX_OFILE_ALIGNMENT (128 * 8)
3981 +
3982 +/* Alignment in bits to be given to a structure bit field that follows an empty
3983 +   field such as `int : 0;'.  */
3984 +#define EMPTY_FIELD_BOUNDARY 32
3985 +
3986 +/* All structures must be a multiple of 32 bits in size.  */
3987 +#define STRUCTURE_SIZE_BOUNDARY 32
3988 +
3989 +/* A bit-field declared as `int' forces `int' alignment for the struct.  */
3990 +#define PCC_BITFIELD_TYPE_MATTERS 1
3991 +
3992 +/* For Ubicom32 we absolutely require that data be aligned with nominal
3993 +   alignment.  */
3994 +#define STRICT_ALIGNMENT 1
3995 +
3996 +/* Make strcpy of constants fast.  */
3997 +#define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
3998 +  (TREE_CODE (EXP) == STRING_CST       \
3999 +   && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
4000 +
4001 +/* Define this macro as an expression for the alignment of a structure
4002 +   (given by STRUCT as a tree node) if the alignment computed in the
4003 +   usual way is COMPUTED and the alignment explicitly specified was
4004 +   SPECIFIED. */
4005 +#define DATA_ALIGNMENT(TYPE, ALIGN)                                    \
4006 +  ((((ALIGN) < BITS_PER_WORD)                                          \
4007 +    && (TREE_CODE (TYPE) == ARRAY_TYPE                                 \
4008 +       || TREE_CODE (TYPE) == UNION_TYPE                               \
4009 +       || TREE_CODE (TYPE) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN))
4010 +
4011 +#define LOCAL_ALIGNMENT(TYPE,ALIGN) DATA_ALIGNMENT(TYPE,ALIGN)
4012 +
4013 +/* For Ubicom32 we default to unsigned chars.  */
4014 +#define DEFAULT_SIGNED_CHAR 0
4015 +
4016 +/* Machine-specific data register numbers.  */
4017 +#define FIRST_DATA_REGNUM 0
4018 +#define D10_REGNUM 10
4019 +#define D11_REGNUM 11
4020 +#define D12_REGNUM 12
4021 +#define D13_REGNUM 13
4022 +#define LAST_DATA_REGNUM 15
4023 +
4024 +/* Machine-specific address register numbers.  */
4025 +#define FIRST_ADDRESS_REGNUM 16
4026 +#define LAST_ADDRESS_REGNUM 22
4027 +
4028 +/* Register numbers used for passing a function's static chain pointer.  If
4029 +   register windows are used, the register number as seen by the called
4030 +   function is `STATIC_CHAIN_INCOMING_REGNUM', while the register number as
4031 +   seen by the calling function is `STATIC_CHAIN_REGNUM'.  If these registers
4032 +   are the same, `STATIC_CHAIN_INCOMING_REGNUM' need not be defined.
4033 +
4034 +   The static chain register need not be a fixed register.
4035 +
4036 +   If the static chain is passed in memory, these macros should not be defined;
4037 +   instead, the next two macros should be defined.  */
4038 +#define STATIC_CHAIN_REGNUM (FIRST_ADDRESS_REGNUM + 1)
4039 +
4040 +/* The register number of the frame pointer register, which is used to access
4041 +   automatic variables in the stack frame.  We generally eliminate this anyway
4042 +   for Ubicom32 but we make it A6 by default.  */
4043 +#define FRAME_POINTER_REGNUM (LAST_ADDRESS_REGNUM)
4044 +
4045 +/* The register number of the stack pointer register, which is also be a
4046 +   fixed register according to `FIXED_REGISTERS'.  For Ubicom32 we don't
4047 +   have a hardware requirement about which register this is, but by convention
4048 +   we use A7.  */
4049 +#define STACK_POINTER_REGNUM (LAST_ADDRESS_REGNUM + 1)
4050 +
4051 +/* Machine-specific accumulator register numbers.  */
4052 +#define ACC0_HI_REGNUM 24
4053 +#define ACC0_LO_REGNUM 25
4054 +#define ACC1_HI_REGNUM 26
4055 +#define ACC1_LO_REGNUM 27
4056 +
4057 +/* source3 register number */
4058 +#define SOURCE3_REGNUM 28
4059 +
4060 +/* The register number of the arg pointer register, which is used to access the
4061 +   function's argument list.  On some machines, this is the same as the frame
4062 +   pointer register.  On some machines, the hardware determines which register
4063 +   this is.  On other machines, you can choose any register you wish for this
4064 +   purpose.  If this is not the same register as the frame pointer register,
4065 +   then you must mark it as a fixed register according to `FIXED_REGISTERS', or
4066 +   arrange to be able to eliminate it.  */
4067 +#define ARG_POINTER_REGNUM 29
4068 +
4069 +/* Pseudo-reg for condition code.  */
4070 +#define CC_REGNUM 30
4071 +
4072 +/* Interrupt set/clear registers.  */
4073 +#define INT_SET0_REGNUM 31
4074 +#define INT_SET1_REGNUM 32
4075 +#define INT_CLR0_REGNUM 33
4076 +#define INT_CLR1_REGNUM 34
4077 +
4078 +/* Scratchpad registers.  */
4079 +#define SCRATCHPAD0_REGNUM 35
4080 +#define SCRATCHPAD1_REGNUM 36
4081 +#define SCRATCHPAD2_REGNUM 37
4082 +#define SCRATCHPAD3_REGNUM 38
4083 +
4084 +/* FDPIC register.  */
4085 +#define FDPIC_REGNUM 16
4086 +
4087 +/* Number of hardware registers known to the compiler.  They receive numbers 0
4088 +   through `FIRST_PSEUDO_REGISTER-1'; thus, the first pseudo register's number
4089 +   really is assigned the number `FIRST_PSEUDO_REGISTER'.  */
4090 +#define FIRST_PSEUDO_REGISTER 39
4091 +
4092 +/* An initializer that says which registers are used for fixed purposes all
4093 +   throughout the compiled code and are therefore not available for general
4094 +   allocation.  These would include the stack pointer, the frame pointer
4095 +   (except on machines where that can be used as a general register when no
4096 +   frame pointer is needed), the program counter on machines where that is
4097 +   considered one of the addressable registers, and any other numbered register
4098 +   with a standard use.
4099 +
4100 +   This information is expressed as a sequence of numbers, separated by commas
4101 +   and surrounded by braces.  The Nth number is 1 if register N is fixed, 0
4102 +   otherwise.
4103 +
4104 +   The table initialized from this macro, and the table initialized by the
4105 +   following one, may be overridden at run time either automatically, by the
4106 +   actions of the macro `CONDITIONAL_REGISTER_USAGE', or by the user with the
4107 +   command options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'.  */
4108 +#define FIXED_REGISTERS                                        \
4109 +  {                                                    \
4110 +    0, 0, 0, 0, 0, 0, 0, 0,    /* d0 - d7 */           \
4111 +    0, 0, 0, 0, 0, 0, 0, 1,    /* d8 - d15 */          \
4112 +    0, 0, 0, 0, 0, 0, 0, 1,    /* a0 - a7 */           \
4113 +    0, 0,                      /* acc0 hi/lo */        \
4114 +    0, 0,                      /* acc1 hi/lo */        \
4115 +    0,                         /* source3 */           \
4116 +    1,                         /* arg */               \
4117 +    1,                         /* cc */                \
4118 +    1, 1,                      /* int_set[01] */       \
4119 +    1, 1,                      /* int_clr[01] */       \
4120 +    1, 1, 1, 1                 /* scratchpad[0123] */  \
4121 +  }
4122 +
4123 +/* Like `FIXED_REGISTERS' but has 1 for each register that is clobbered (in
4124 +   general) by function calls as well as for fixed registers.  This macro
4125 +   therefore identifies the registers that are not available for general
4126 +   allocation of values that must live across function calls.
4127 +
4128 +   If a register has 0 in `CALL_USED_REGISTERS', the compiler automatically
4129 +   saves it on function entry and restores it on function exit, if the register
4130 +   is used within the function.  */
4131 +#define CALL_USED_REGISTERS                            \
4132 +  {                                                    \
4133 +    1, 1, 1, 1, 1, 1, 1, 1,    /* d0 - d7 */           \
4134 +    1, 1, 0, 0, 0, 0, 1, 1,    /* d8 - d15 */          \
4135 +    1, 0, 0, 1, 1, 1, 0, 1,    /* a0 - a7 */           \
4136 +    1, 1,                      /* acc0 hi/lo */        \
4137 +    1, 1,                      /* acc1 hi/lo */        \
4138 +    1,                         /* source3 */           \
4139 +    1,                         /* arg */               \
4140 +    1,                         /* cc */                \
4141 +    1, 1,                      /* int_set[01] */       \
4142 +    1, 1,                      /* int_clr[01] */       \
4143 +    1, 1, 1, 1                 /* scratchpad[0123] */  \
4144 +  }
4145 +
4146 +/* How to refer to registers in assembler output.
4147 +   This sequence is indexed by compiler's hard-register-number (see above).  */
4148 +
4149 +/* A C initializer containing the assembler's names for the machine registers,
4150 +   each one as a C string constant.  This is what translates register numbers
4151 +   in the compiler into assembler language.  */
4152 +#define REGISTER_NAMES                                         \
4153 +  {                                                            \
4154 +    "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",            \
4155 +    "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",      \
4156 +    "a0", "a1", "a2", "a3", "a4", "a5", "a6", "sp",            \
4157 +    "acc0_hi", "acc0_lo",                                      \
4158 +    "acc1_hi", "acc1_lo",                                      \
4159 +    "source3",                                                 \
4160 +    "arg",                                                     \
4161 +    "cc",                                                      \
4162 +    "int_set0", "int_set1",                                    \
4163 +    "int_clr0", "int_clr1",                                    \
4164 +    "scratchpad0", "scratchpad1", "scratchpad2", "scratchpad3" \
4165 +  }
4166 +
4167 +#define CONDITIONAL_REGISTER_USAGE                             \
4168 +  ubicom32_conditional_register_usage ();
4169 +
4170 +/* Order of allocation of registers.  */
4171 +
4172 +/* If defined, an initializer for a vector of integers, containing the numbers
4173 +   of hard registers in the order in which GNU CC should prefer to use them
4174 +   (from most preferred to least).
4175 +
4176 +   For Ubicom32 we try using caller-clobbered data registers first, then
4177 +   callee-saved data registers, then caller-clobbered address registers,
4178 +   then callee-saved address registers and finally everything else.
4179 +
4180 +   The caller-clobbered registers are usually slightly cheaper to use because
4181 +   there's no need to save/restore.  */
4182 +#define REG_ALLOC_ORDER                                                \
4183 +  {                                                            \
4184 +    0, 1, 2, 3, 4,             /* d0 - d4 */                   \
4185 +    5, 6, 7, 8, 9,             /* d5 - d9 */                   \
4186 +    14,                                /* d14 */                       \
4187 +    10, 11, 12, 13,            /* d10 - d13 */                 \
4188 +    19, 20, 16, 21,            /* a3, a4, a0, a5 */            \
4189 +    17, 18, 22,                        /* a1, a2, a6 */                \
4190 +    24, 25,                    /* acc0 hi/lo */                \
4191 +    26, 27,                    /* acc0 hi/lo */                \
4192 +    28                         /* source3 */                   \
4193 +  }
4194 +
4195 +/* C expression for the number of consecutive hard registers, starting at
4196 +   register number REGNO, required to hold a value of mode MODE.  */
4197 +#define HARD_REGNO_NREGS(REGNO, MODE) \
4198 +  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
4199 +
4200 +/* Most registers can hold QImode, HImode and SImode values but we have to
4201 +   be able to indicate any hard registers that cannot hold values with some
4202 +   modes.  */
4203 +#define HARD_REGNO_MODE_OK(REGNO, MODE) \
4204 +  ubicom32_hard_regno_mode_ok(REGNO, MODE)
4205 +
4206 +/* We can rename most registers aside from the FDPIC register if we're using
4207 +   FDPIC.  */
4208 +#define HARD_REGNO_RENAME_OK(from, to) (TARGET_FDPIC ? ((to) != FDPIC_REGNUM) : 1)
4209 +
4210 +/* A C expression that is nonzero if it is desirable to choose register
4211 +   allocation so as to avoid move instructions between a value of mode MODE1
4212 +   and a value of mode MODE2.
4213 +
4214 +   If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, MODE2)' are
4215 +   ever different for any R, then `MODES_TIEABLE_P (MODE1, MODE2)' must be
4216 +   zero.  */
4217 +#define MODES_TIEABLE_P(MODE1, MODE2) 1
4218 +
4219 +/* An enumeral type that must be defined with all the register class names as
4220 +   enumeral values.  `NO_REGS' must be first.  `ALL_REGS' must be the last
4221 +   register class, followed by one more enumeral value, `LIM_REG_CLASSES',
4222 +   which is not a register class but rather tells how many classes there are.
4223 +
4224 +   Each register class has a number, which is the value of casting the class
4225 +   name to type `int'.  The number serves as an index in many of the tables
4226 +   described below.  */
4227 +
4228 +enum reg_class
4229 +{
4230 +  NO_REGS,
4231 +  DATA_REGS,
4232 +  FDPIC_REG,
4233 +  ADDRESS_REGS,
4234 +  ALL_ADDRESS_REGS,
4235 +  ACC_LO_REGS,
4236 +  ACC_REGS,
4237 +  CC_REG,
4238 +  DATA_ACC_REGS,
4239 +  SOURCE3_REG,
4240 +  SPECIAL_REGS,
4241 +  GENERAL_REGS,
4242 +  ALL_REGS,
4243 +  LIM_REG_CLASSES
4244 +};
4245 +
4246 +/* The number of distinct register classes.  */
4247 +#define N_REG_CLASSES (int) LIM_REG_CLASSES
4248 +
4249 +/* An initializer containing the names of the register classes as C string
4250 +   constants.  These names are used in writing some of the debugging dumps.  */
4251 +
4252 +#define REG_CLASS_NAMES                \
4253 +{                              \
4254 +  "NO_REGS",                   \
4255 +  "DATA_REGS",                 \
4256 +  "FDPIC_REG",                 \
4257 +  "ADDRESS_REGS",              \
4258 +  "ALL_ADDRESS_REGS",          \
4259 +  "ACC_LO_REGS",               \
4260 +  "ACC_REGS",                  \
4261 +  "CC_REG",                    \
4262 +  "DATA_ACC_REGS",             \
4263 +  "SOURCE3_REG",               \
4264 +  "SPECIAL_REGS",              \
4265 +  "GENERAL_REGS",              \
4266 +  "ALL_REGS",                  \
4267 +  "LIM_REGS"                   \
4268 +}
4269 +
4270 +/* An initializer containing the contents of the register classes, as integers
4271 +   which are bit masks.  The Nth integer specifies the contents of class N.
4272 +   The way the integer MASK is interpreted is that register R is in the class
4273 +   if `MASK & (1 << R)' is 1.
4274 +
4275 +   When the machine has more than 32 registers, an integer does not suffice.
4276 +   Then the integers are replaced by sub-initializers, braced groupings
4277 +   containing several integers.  Each sub-initializer must be suitable as an
4278 +   initializer for the type `HARD_REG_SET' which is defined in
4279 +   `hard-reg-set.h'.  */
4280 +#define REG_CLASS_CONTENTS                                     \
4281 +{                                                              \
4282 +  {0x00000000, 0x00000000},    /* No regs */                   \
4283 +  {0x0000ffff, 0x00000000},    /* DATA_REGS */                 \
4284 +  {0x00010000, 0x00000000},    /* FDPIC_REG */                 \
4285 +  {0x20fe0000, 0x00000000},    /* ADDRESS_REGS */              \
4286 +  {0x20ff0000, 0x00000000},    /* ALL_ADDRESS_REGS */          \
4287 +  {0x0a000000, 0x00000000},    /* ACC_LO_REGS */               \
4288 +  {0x0f000000, 0x00000000},    /* ACC_REGS */                  \
4289 +  {0x40000000, 0x00000000},    /* CC_REG */                    \
4290 +  {0x0f00ffff, 0x00000000},    /* DATA_ACC_REGS */             \
4291 +  {0x10000000, 0x00000000},    /* SOURGE3_REG */               \
4292 +  {0x80000000, 0x0000007f},    /* SPECIAL_REGS */              \
4293 +  {0xbfffffff, 0x0000007f},    /* GENERAL_REGS */              \
4294 +  {0xbfffffff, 0x0000007f}     /* ALL_REGS     */              \
4295 +}
4296 +
4297 +extern enum reg_class const ubicom32_regclass_map[FIRST_PSEUDO_REGISTER];
4298 +
4299 +/* A C expression whose value is a register class containing hard register
4300 +   REGNO.  In general there is more than one such class; choose a class which
4301 +   is "minimal", meaning that no smaller class also contains the register.  */
4302 +#define REGNO_REG_CLASS(REGNO) (ubicom32_regclass_map[REGNO])
4303 +
4304 +#define IRA_COVER_CLASSES              \
4305 +{                                      \
4306 +  GENERAL_REGS,                                \
4307 +  LIM_REG_CLASSES                      \
4308 +}
4309 +
4310 +/* Ubicom32 base registers must be address registers since addresses can
4311 +   only be reached via address registers.  */
4312 +#define BASE_REG_CLASS ALL_ADDRESS_REGS
4313 +
4314 +/* Ubicom32 index registers must be data registers since we cannot add
4315 +   two address registers together to form an address.  */
4316 +#define INDEX_REG_CLASS DATA_REGS
4317 +
4318 +/* A C expression which is nonzero if register number NUM is suitable for use
4319 +   as a base register in operand addresses.  It may be either a suitable hard
4320 +   register or a pseudo register that has been allocated such a hard register.  */
4321 +
4322 +#ifndef REG_OK_STRICT
4323 +#define REGNO_OK_FOR_BASE_P(regno) \
4324 +  ubicom32_regno_ok_for_base_p (regno, 0)
4325 +#else
4326 +#define REGNO_OK_FOR_BASE_P(regno) \
4327 +  ubicom32_regno_ok_for_base_p (regno, 1)
4328 +#endif
4329 +
4330 +/* A C expression which is nonzero if register number NUM is suitable for use
4331 +   as an index register in operand addresses.  It may be either a suitable hard
4332 +   register or a pseudo register that has been allocated such a hard register.
4333 +
4334 +   The difference between an index register and a base register is that the
4335 +   index register may be scaled.  If an address involves the sum of two
4336 +   registers, neither one of them scaled, then either one may be labeled the
4337 +   "base" and the other the "index"; but whichever labeling is used must fit
4338 +   the machine's constraints of which registers may serve in each capacity.
4339 +   The compiler will try both labelings, looking for one that is valid, and
4340 +   will reload one or both registers only if neither labeling works.  */
4341 +#ifndef REG_OK_STRICT
4342 +#define REGNO_OK_FOR_INDEX_P(regno) \
4343 +  ubicom32_regno_ok_for_index_p (regno, 0)
4344 +#else
4345 +#define REGNO_OK_FOR_INDEX_P(regno) \
4346 +  ubicom32_regno_ok_for_index_p (regno, 1)
4347 +#endif
4348 +
4349 +/* Attempt to restrict the register class we need to copy value X intoto the
4350 +   would-be register class CLASS.  Most things are fine for Ubicom32 but we
4351 +   have to restrict certain types of address loads.  */
4352 +#define PREFERRED_RELOAD_CLASS(X, CLASS) \
4353 +  ubicom32_preferred_reload_class (X, CLASS)
4354 +
4355 +/* A C expression for the maximum number of consecutive registers of
4356 +   class CLASS needed to hold a value of mode MODE.  For Ubicom32 this
4357 +   is pretty much identical to HARD_REGNO_NREGS.  */
4358 +#define CLASS_MAX_NREGS(CLASS, MODE)   \
4359 +  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
4360 +
4361 +/* For Ubicom32 the stack grows downwards when we push a word onto the stack
4362 +   - i.e. it moves to a smaller address.  */
4363 +#define STACK_GROWS_DOWNWARD 1
4364 +
4365 +/* Offset from the frame pointer to the first local variable slot to
4366 +   be allocated.  */
4367 +#define STARTING_FRAME_OFFSET 0
4368 +
4369 +/* Offset from the argument pointer register to the first argument's
4370 +   address.  */
4371 +#define FIRST_PARM_OFFSET(FNDECL) 0
4372 +
4373 +/* A C expression whose value is RTL representing the value of the return
4374 +   address for the frame COUNT steps up from the current frame, after the
4375 +   prologue.  FRAMEADDR is the frame pointer of the COUNT frame, or the frame
4376 +   pointer of the COUNT - 1 frame if `RETURN_ADDR_IN_PREVIOUS_FRAME' is
4377 +   defined.
4378 +
4379 +   The value of the expression must always be the correct address when COUNT is
4380 +   zero, but may be `NULL_RTX' if there is not way to determine the return
4381 +   address of other frames.  */
4382 +#define RETURN_ADDR_RTX(COUNT, FRAME) \
4383 +  ubicom32_return_addr_rtx (COUNT, FRAME)
4384 +
4385 +/* Register That Address the Stack Frame.  */
4386 +
4387 +/* We don't actually require a frame pointer in most functions with the
4388 +   Ubicom32 architecture so we allow it to be eliminated.  */
4389 +#define FRAME_POINTER_REQUIRED 0
4390 +
4391 +/* Macro that defines a table of register pairs used to eliminate unecessary
4392 +   registers that point into the stack frame.
4393 +
4394 +   For Ubicom32 we don't generally need an arg pointer of a frame pointer
4395 +   so we allow the arg pointer to be replaced by either the frame pointer or
4396 +   the stack pointer.  We also allow the frame pointer to be replaced by
4397 +   the stack pointer.  */
4398 +#define ELIMINABLE_REGS                                        \
4399 +{                                                      \
4400 +  {ARG_POINTER_REGNUM,  STACK_POINTER_REGNUM},         \
4401 +  {ARG_POINTER_REGNUM,  FRAME_POINTER_REGNUM},         \
4402 +  {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}         \
4403 +}
4404 +
4405 +/* Let the compiler know that we want to use the ELIMINABLE_REGS macro
4406 +   above.  */
4407 +#define CAN_ELIMINATE(FROM, TO) 1
4408 +
4409 +/* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'.  It specifies the
4410 +   initial difference between the specified pair of registers.  This macro must
4411 +   be defined if `ELIMINABLE_REGS' is defined.  */
4412 +#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
4413 +  (OFFSET) = ubicom32_initial_elimination_offset (FROM, TO)
4414 +
4415 +/* If defined, the maximum amount of space required for outgoing arguments will
4416 +   be computed and placed into the variable
4417 +   `current_function_outgoing_args_size'.  No space will be pushed onto the
4418 +   stack for each call; instead, the function prologue should increase the
4419 +   stack frame size by this amount.
4420 +
4421 +   Defining both `PUSH_ROUNDING' and `ACCUMULATE_OUTGOING_ARGS' is not
4422 +   proper.  */
4423 +#define ACCUMULATE_OUTGOING_ARGS 1
4424 +
4425 +/* Define this macro if functions should assume that stack space has been
4426 +   allocated for arguments even when their values are passed in registers.
4427 +
4428 +   The value of this macro is the size, in bytes, of the area reserved for
4429 +   arguments passed in registers for the function represented by FNDECL.
4430 +
4431 +   This space can be allocated by the caller, or be a part of the
4432 +   machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE' says
4433 +   which.  */
4434 +#define REG_PARM_STACK_SPACE(FNDECL) ubicom32_reg_parm_stack_space(FNDECL)
4435 +
4436 +/* A C expression that should indicate the number of bytes of its own arguments
4437 +   that a function pops on returning, or 0 if the function pops no arguments
4438 +   and the caller must therefore pop them all after the function returns.
4439 +
4440 +   FUNDECL is a C variable whose value is a tree node that describes the
4441 +   function in question.  Normally it is a node of type `FUNCTION_DECL' that
4442 +   describes the declaration of the function.  From this it is possible to
4443 +   obtain the DECL_MACHINE_ATTRIBUTES of the function.
4444 +
4445 +   FUNTYPE is a C variable whose value is a tree node that describes the
4446 +   function in question.  Normally it is a node of type `FUNCTION_TYPE' that
4447 +   describes the data type of the function.  From this it is possible to obtain
4448 +   the data types of the value and arguments (if known).
4449 +
4450 +   When a call to a library function is being considered, FUNTYPE will contain
4451 +   an identifier node for the library function.  Thus, if you need to
4452 +   distinguish among various library functions, you can do so by their names.
4453 +   Note that "library function" in this context means a function used to
4454 +   perform arithmetic, whose name is known specially in the compiler and was
4455 +   not mentioned in the C code being compiled.
4456 +
4457 +   STACK-SIZE is the number of bytes of arguments passed on the stack.  If a
4458 +   variable number of bytes is passed, it is zero, and argument popping will
4459 +   always be the responsibility of the calling function.
4460 +
4461 +   On the Vax, all functions always pop their arguments, so the definition of
4462 +   this macro is STACK-SIZE.  On the 68000, using the standard calling
4463 +   convention, no functions pop their arguments, so the value of the macro is
4464 +   always 0 in this case.  But an alternative calling convention is available
4465 +   in which functions that take a fixed number of arguments pop them but other
4466 +   functions (such as `printf') pop nothing (the caller pops all).  When this
4467 +   convention is in use, FUNTYPE is examined to determine whether a function
4468 +   takes a fixed number of arguments.  */
4469 +#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
4470 +
4471 +/* A C expression that controls whether a function argument is passed in a
4472 +   register, and which register.
4473 +
4474 +   The arguments are CUM, of type CUMULATIVE_ARGS, which summarizes (in a way
4475 +   defined by INIT_CUMULATIVE_ARGS and FUNCTION_ARG_ADVANCE) all of the previous
4476 +   arguments so far passed in registers; MODE, the machine mode of the argument;
4477 +   TYPE, the data type of the argument as a tree node or 0 if that is not known
4478 +   (which happens for C support library functions); and NAMED, which is 1 for an
4479 +   ordinary argument and 0 for nameless arguments that correspond to `...' in the
4480 +   called function's prototype.
4481 +
4482 +   The value of the expression should either be a `reg' RTX for the hard
4483 +   register in which to pass the argument, or zero to pass the argument on the
4484 +   stack.
4485 +
4486 +   For machines like the Vax and 68000, where normally all arguments are
4487 +   pushed, zero suffices as a definition.
4488 +
4489 +   The usual way to make the ANSI library `stdarg.h' work on a machine where
4490 +   some arguments are usually passed in registers, is to cause nameless
4491 +   arguments to be passed on the stack instead.  This is done by making
4492 +   `FUNCTION_ARG' return 0 whenever NAMED is 0.
4493 +
4494 +   You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the definition of
4495 +   this macro to determine if this argument is of a type that must be passed in
4496 +   the stack.  If `REG_PARM_STACK_SPACE' is not defined and `FUNCTION_ARG'
4497 +   returns non-zero for such an argument, the compiler will abort.  If
4498 +   `REG_PARM_STACK_SPACE' is defined, the argument will be computed in the
4499 +   stack and then loaded into a register.  */
4500 +#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
4501 +  function_arg (&CUM, MODE, TYPE, NAMED)
4502 +
4503 +#define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \
4504 +  function_incoming_arg (&CUM, MODE, TYPE, NAMED)
4505 +
4506 +/* A C expression for the number of words, at the beginning of an argument,
4507 +   must be put in registers.  The value must be zero for arguments that are
4508 +   passed entirely in registers or that are entirely pushed on the stack.
4509 +
4510 +   On some machines, certain arguments must be passed partially in registers
4511 +   and partially in memory.  On these machines, typically the first N words of
4512 +   arguments are passed in registers, and the rest on the stack.  If a
4513 +   multi-word argument (a `double' or a structure) crosses that boundary, its
4514 +   first few words must be passed in registers and the rest must be pushed.
4515 +   This macro tells the compiler when this occurs, and how many of the words
4516 +   should go in registers.
4517 +
4518 +   `FUNCTION_ARG' for these arguments should return the first register to be
4519 +   used by the caller for this argument; likewise `FUNCTION_INCOMING_ARG', for
4520 +   the called function.  */
4521 +
4522 +/* A C expression that indicates when an argument must be passed by reference.
4523 +   If nonzero for an argument, a copy of that argument is made in memory and a
4524 +   pointer to the argument is passed instead of the argument itself.  The
4525 +   pointer is passed in whatever way is appropriate for passing a pointer to
4526 +   that type.
4527 +
4528 +   On machines where `REG_PARM_STACK_SPACE' is not defined, a suitable
4529 +   definition of this macro might be
4530 +       #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED)  \
4531 +         MUST_PASS_IN_STACK (MODE, TYPE)  */
4532 +
4533 +/* If defined, a C expression that indicates when it is the called function's
4534 +   responsibility to make a copy of arguments passed by invisible reference.
4535 +   Normally, the caller makes a copy and passes the address of the copy to the
4536 +   routine being called.  When FUNCTION_ARG_CALLEE_COPIES is defined and is
4537 +   nonzero, the caller does not make a copy.  Instead, it passes a pointer to
4538 +   the "live" value.  The called function must not modify this value.  If it
4539 +   can be determined that the value won't be modified, it need not make a copy;
4540 +   otherwise a copy must be made.  */
4541 +
4542 +/* A C type for declaring a variable that is used as the first argument of
4543 +   `FUNCTION_ARG' and other related values.  For some target machines, the type
4544 +   `int' suffices and can hold the number of bytes of argument so far.
4545 +
4546 +   There is no need to record in `CUMULATIVE_ARGS' anything about the arguments
4547 +   that have been passed on the stack.  The compiler has other variables to
4548 +   keep track of that.  For target machines on which all arguments are passed
4549 +   on the stack, there is no need to store anything in `CUMULATIVE_ARGS';
4550 +   however, the data structure must exist and should not be empty, so use
4551 +   `int'.  */
4552 +struct cum_arg
4553 +{
4554 +  int nbytes;
4555 +  int reg;
4556 +  int stdarg;
4557 +};
4558 +#define CUMULATIVE_ARGS struct cum_arg
4559 +
4560 +/* A C statement (sans semicolon) for initializing the variable CUM for the
4561 +   state at the beginning of the argument list.  The variable has type
4562 +   `CUMULATIVE_ARGS'.  The value of FNTYPE is the tree node for the data type
4563 +   of the function which will receive the args, or 0 if the args are to a
4564 +   compiler support library function.  The value of INDIRECT is nonzero when
4565 +   processing an indirect call, for example a call through a function pointer.
4566 +   The value of INDIRECT is zero for a call to an explicitly named function, a
4567 +   library function call, or when `INIT_CUMULATIVE_ARGS' is used to find
4568 +   arguments for the function being compiled.
4569 +
4570 +   When processing a call to a compiler support library function, LIBNAME
4571 +   identifies which one.  It is a `symbol_ref' rtx which contains the name of
4572 +   the function, as a string.  LIBNAME is 0 when an ordinary C function call is
4573 +   being processed.  Thus, each time this macro is called, either LIBNAME or
4574 +   FNTYPE is nonzero, but never both of them at once.  */
4575 +
4576 +#define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT, NAMED_ARGS)  \
4577 + init_cumulative_args (&(CUM), FNTYPE, LIBNAME, INDIRECT);
4578 +
4579 +/* A C statement (sans semicolon) to update the summarizer variable CUM to
4580 +   advance past an argument in the argument list.  The values MODE, TYPE and
4581 +   NAMED describe that argument.  Once this is done, the variable CUM is
4582 +   suitable for analyzing the *following* argument with `FUNCTION_ARG', etc.
4583 +
4584 +   This macro need not do anything if the argument in question was passed on
4585 +   the stack.  The compiler knows how to track the amount of stack space used
4586 +   for arguments without any special help.  */
4587 +#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)   \
4588 + ((CUM).nbytes += ((MODE) != BLKmode                   \
4589 +                  ? (GET_MODE_SIZE (MODE) + 3) & ~3    \
4590 +                  : (int_size_in_bytes (TYPE) + 3) & ~3))
4591 +
4592 +/* For the Ubicom32 we define the upper function argument register here.  */
4593 +#define UBICOM32_FUNCTION_ARG_REGS 10
4594 +
4595 +/* A C expression that is nonzero if REGNO is the number of a hard register in
4596 +   which function arguments are sometimes passed.  This does *not* include
4597 +   implicit arguments such as the static chain and the structure-value address.
4598 +   On many machines, no registers can be used for this purpose since all
4599 +   function arguments are pushed on the stack.  */
4600 +#define FUNCTION_ARG_REGNO_P(N) ((N) < UBICOM32_FUNCTION_ARG_REGS)
4601 +
4602 +\f
4603 +/* How Scalar Function Values are Returned.  */
4604 +
4605 +/* The number of the hard register that is used to return a scalar value from a
4606 +   function call.  */
4607 +#define RETURN_VALUE_REGNUM 0
4608 +
4609 +/* A C expression to create an RTX representing the place where a function
4610 +   returns a value of data type VALTYPE.  VALTYPE is a tree node representing a
4611 +   data type.  Write `TYPE_MODE (VALTYPE)' to get the machine mode used to
4612 +   represent that type.  On many machines, only the mode is relevant.
4613 +   (Actually, on most machines, scalar values are returned in the same place
4614 +   regardless of mode).
4615 +
4616 +   If `PROMOTE_FUNCTION_RETURN' is defined, you must apply the same promotion
4617 +   rules specified in `PROMOTE_MODE' if VALTYPE is a scalar type.
4618 +
4619 +   If the precise function being called is known, FUNC is a tree node
4620 +   (`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer.  This makes it
4621 +   possible to use a different value-returning convention for specific
4622 +   functions when all their calls are known.
4623 +
4624 +   `FUNCTION_VALUE' is not used for return vales with aggregate data types,
4625 +   because these are returned in another way.  See `STRUCT_VALUE_REGNUM' and
4626 +   related macros, below.  */
4627 +#define FUNCTION_VALUE(VALTYPE, FUNC) \
4628 +  gen_rtx_REG (TYPE_MODE (VALTYPE), FIRST_DATA_REGNUM)
4629 +
4630 +/* A C expression to create an RTX representing the place where a library
4631 +   function returns a value of mode MODE.
4632 +
4633 +   Note that "library function" in this context means a compiler support
4634 +   routine, used to perform arithmetic, whose name is known specially by the
4635 +   compiler and was not mentioned in the C code being compiled.
4636 +
4637 +   The definition of `LIBRARY_VALUE' need not be concerned aggregate data
4638 +   types, because none of the library functions returns such types.  */
4639 +#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, FIRST_DATA_REGNUM)
4640 +
4641 +/* A C expression that is nonzero if REGNO is the number of a hard register in
4642 +   which the values of called function may come back.
4643 +
4644 +   A register whose use for returning values is limited to serving as the
4645 +   second of a pair (for a value of type `double', say) need not be recognized
4646 +   by this macro.  So for most machines, this definition suffices:
4647 +
4648 +       #define FUNCTION_VALUE_REGNO_P(N) ((N) == RETURN)
4649 +
4650 +   If the machine has register windows, so that the caller and the called
4651 +   function use different registers for the return value, this macro should
4652 +   recognize only the caller's register numbers.  */
4653 +#define FUNCTION_VALUE_REGNO_P(N) ((N) == FIRST_DATA_REGNUM)
4654 +
4655 +\f
4656 +/* How Large Values are Returned.  */
4657 +
4658 +/* A C expression which can inhibit the returning of certain function values in
4659 +   registers, based on the type of value.  A nonzero value says to return the
4660 +   function value in memory, just as large structures are always returned.
4661 +   Here TYPE will be a C expression of type `tree', representing the data type
4662 +   of the value.
4663 +
4664 +   Note that values of mode `BLKmode' must be explicitly handled by this macro.
4665 +   Also, the option `-fpcc-struct-return' takes effect regardless of this
4666 +   macro.  On most systems, it is possible to leave the macro undefined; this
4667 +   causes a default definition to be used, whose value is the constant 1 for
4668 +   `BLKmode' values, and 0 otherwise.
4669 +
4670 +   Do not use this macro to indicate that structures and unions should always
4671 +   be returned in memory.  You should instead use `DEFAULT_PCC_STRUCT_RETURN'
4672 +   to indicate this.  */
4673 +#define RETURN_IN_MEMORY(TYPE)  \
4674 +  (int_size_in_bytes (TYPE) > 8 || TYPE_MODE (TYPE) == BLKmode)
4675 +
4676 +/* Define this macro to be 1 if all structure and union return values must be
4677 +   in memory.  Since this results in slower code, this should be defined only
4678 +   if needed for compatibility with other compilers or with an ABI.  If you
4679 +   define this macro to be 0, then the conventions used for structure and union
4680 +   return values are decided by the `RETURN_IN_MEMORY' macro.
4681 +
4682 +   If not defined, this defaults to the value 1.  */
4683 +#define DEFAULT_PCC_STRUCT_RETURN 0
4684 +
4685 +/*   If the structure value address is not passed in a register, define
4686 +     `STRUCT_VALUE' as an expression returning an RTX for the place
4687 +     where the address is passed.  If it returns 0, the address is
4688 +     passed as an "invisible" first argument.  */
4689 +#define STRUCT_VALUE 0
4690 +
4691 +/* Define this macro as a C expression that is nonzero if the return
4692 +   instruction or the function epilogue ignores the value of the stack pointer;
4693 +   in other words, if it is safe to delete an instruction to adjust the stack
4694 +   pointer before a return from the function.
4695 +
4696 +   Note that this macro's value is relevant only for functions for which frame
4697 +   pointers are maintained.  It is never safe to delete a final stack
4698 +   adjustment in a function that has no frame pointer, and the compiler knows
4699 +   this regardless of `EXIT_IGNORE_STACK'.  */
4700 +#define EXIT_IGNORE_STACK 1
4701 +
4702 +/* A C statement or compound statement to output to FILE some assembler code to
4703 +   call the profiling subroutine `mcount'.  Before calling, the assembler code
4704 +   must load the address of a counter variable into a register where `mcount'
4705 +   expects to find the address.  The name of this variable is `LP' followed by
4706 +   the number LABELNO, so you would generate the name using `LP%d' in a
4707 +   `fprintf'.
4708 +
4709 +   The details of how the address should be passed to `mcount' are determined
4710 +   by your operating system environment, not by GNU CC.  To figure them out,
4711 +   compile a small program for profiling using the system's installed C
4712 +   compiler and look at the assembler code that results.
4713 +
4714 +   This declaration must be present, but it can be an abort if profiling is
4715 +   not implemented.  */
4716 +
4717 +#define FUNCTION_PROFILER(file, labelno) ubicom32_profiler(file, labelno)
4718 +
4719 +/* A C statement to output, on the stream FILE, assembler code for a block of
4720 +   data that contains the constant parts of a trampoline.  This code should not
4721 +   include a label--the label is taken care of automatically.  */
4722 +#if 0
4723 +#define TRAMPOLINE_TEMPLATE(FILE)                      \
4724 +  do {                                                 \
4725 +    fprintf (FILE, "\tadd -4,sp\n");                   \
4726 +    fprintf (FILE, "\t.long 0x0004fffa\n");            \
4727 +    fprintf (FILE, "\tmov (0,sp),a0\n");               \
4728 +    fprintf (FILE, "\tadd 4,sp\n");                    \
4729 +    fprintf (FILE, "\tmov (13,a0),a1\n");              \
4730 +    fprintf (FILE, "\tmov (17,a0),a0\n");              \
4731 +    fprintf (FILE, "\tjmp (a0)\n");                    \
4732 +    fprintf (FILE, "\t.long 0\n");                     \
4733 +    fprintf (FILE, "\t.long 0\n");                     \
4734 +  } while (0)
4735 +#endif
4736 +
4737 +/* A C expression for the size in bytes of the trampoline, as an integer.  */
4738 +#define TRAMPOLINE_SIZE 0x1b
4739 +
4740 +/* Alignment required for trampolines, in bits.
4741 +
4742 +   If you don't define this macro, the value of `BIGGEST_ALIGNMENT' is used for
4743 +   aligning trampolines.  */
4744 +#define TRAMPOLINE_ALIGNMENT 32
4745 +
4746 +/* A C statement to initialize the variable parts of a trampoline.  ADDR is an
4747 +   RTX for the address of the trampoline; FNADDR is an RTX for the address of
4748 +   the nested function; STATIC_CHAIN is an RTX for the static chain value that
4749 +   should be passed to the function when it is called.  */
4750 +#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT)                      \
4751 +{                                                                      \
4752 +  emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 0x14)), \
4753 +                (CXT));                                                \
4754 +  emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 0x18)), \
4755 +                (FNADDR));                                             \
4756 +}
4757 +
4758 +/* Ubicom32 supports pre and post increment/decrement addressing.  */
4759 +#define HAVE_POST_INCREMENT 1
4760 +#define HAVE_PRE_INCREMENT 1
4761 +#define HAVE_POST_DECREMENT 1
4762 +#define HAVE_PRE_DECREMENT 1
4763 +
4764 +/* Ubicom32 supports pre and post address side-effects with constants
4765 +   other than the size of the memory operand.  */
4766 +#define HAVE_PRE_MODIFY_DISP 1
4767 +#define HAVE_POST_MODIFY_DISP 1
4768 +
4769 +/* A C expression that is 1 if the RTX X is a constant which is a valid
4770 +   address.  On most machines, this can be defined as `CONSTANT_P (X)',
4771 +   but a few machines are more restrictive in which constant addresses
4772 +   are supported.
4773 +
4774 +   `CONSTANT_P' accepts integer-values expressions whose values are not
4775 +   explicitly known, such as `symbol_ref', `label_ref', and `high'
4776 +   expressions and `const' arithmetic expressions, in addition to
4777 +   `const_int' and `const_double' expressions.  */
4778 +#define CONSTANT_ADDRESS_P(X)                                          \
4779 +  (GET_CODE (X) == LABEL_REF                                           \
4780 +   || (GET_CODE (X) == CONST                                           \
4781 +       && GET_CODE (XEXP (X, 0)) == PLUS                               \
4782 +       && GET_CODE (XEXP (XEXP (X, 0), 0)) == LABEL_REF))
4783 +
4784 +/* Ubicom32 supports a maximum of 2 registers in a valid memory address.
4785 +   One is always an address register while a second, optional, one may be a
4786 +   data register.  */
4787 +#define MAX_REGS_PER_ADDRESS 2
4788 +
4789 +/* A C compound statement with a conditional `goto LABEL;' executed if X (an
4790 +   RTX) is a legitimate memory address on the target machine for a memory
4791 +   operand of mode MODE.
4792 +
4793 +   It usually pays to define several simpler macros to serve as subroutines for
4794 +   this one.  Otherwise it may be too complicated to understand.
4795 +
4796 +   This macro must exist in two variants: a strict variant and a non-strict
4797 +   one.  The strict variant is used in the reload pass.  It must be defined so
4798 +   that any pseudo-register that has not been allocated a hard register is
4799 +   considered a memory reference.  In contexts where some kind of register is
4800 +   required, a pseudo-register with no hard register must be rejected.
4801 +
4802 +   The non-strict variant is used in other passes.  It must be defined to
4803 +   accept all pseudo-registers in every context where some kind of register is
4804 +   required.
4805 +
4806 +   Compiler source files that want to use the strict variant of this macro
4807 +   define the macro `REG_OK_STRICT'.  You should use an `#ifdef REG_OK_STRICT'
4808 +   conditional to define the strict variant in that case and the non-strict
4809 +   variant otherwise.
4810 +
4811 +   Subroutines to check for acceptable registers for various purposes (one for
4812 +   base registers, one for index registers, and so on) are typically among the
4813 +   subroutines used to define `GO_IF_LEGITIMATE_ADDRESS'.  Then only these
4814 +   subroutine macros need have two variants; the higher levels of macros may be
4815 +   the same whether strict or not.
4816 +
4817 +   Normally, constant addresses which are the sum of a `symbol_ref' and an
4818 +   integer are stored inside a `const' RTX to mark them as constant.
4819 +   Therefore, there is no need to recognize such sums specifically as
4820 +   legitimate addresses.  Normally you would simply recognize any `const' as
4821 +   legitimate.
4822 +
4823 +   Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle constant sums that
4824 +   are not marked with `const'.  It assumes that a naked `plus' indicates
4825 +   indexing.  If so, then you *must* reject such naked constant sums as
4826 +   illegitimate addresses, so that none of them will be given to
4827 +   `PRINT_OPERAND_ADDRESS'.
4828 +
4829 +   On some machines, whether a symbolic address is legitimate depends on the
4830 +   section that the address refers to.  On these machines, define the macro
4831 +   `ENCODE_SECTION_INFO' to store the information into the `symbol_ref', and
4832 +   then check for it here.  When you see a `const', you will have to look
4833 +   inside it to find the `symbol_ref' in order to determine the section.
4834 +
4835 +   The best way to modify the name string is by adding text to the beginning,
4836 +   with suitable punctuation to prevent any ambiguity.  Allocate the new name
4837 +   in `saveable_obstack'.  You will have to modify `ASM_OUTPUT_LABELREF' to
4838 +   remove and decode the added text and output the name accordingly, and define
4839 +   `STRIP_NAME_ENCODING' to access the original name string.
4840 +
4841 +   You can check the information stored here into the `symbol_ref' in the
4842 +   definitions of the macros `GO_IF_LEGITIMATE_ADDRESS' and
4843 +   `PRINT_OPERAND_ADDRESS'.  */
4844 +/* On the ubicom32, the value in the address register must be
4845 +   in the same memory space/segment as the effective address.
4846 +
4847 +   This is problematical for reload since it does not understand
4848 +   that base+index != index+base in a memory reference.  */
4849 +
4850 +#ifdef REG_OK_STRICT
4851 +#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)        \
4852 +  if (ubicom32_legitimate_address_p (MODE, X, 1)) goto ADDR;
4853 +#else
4854 +#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)        \
4855 +  if (ubicom32_legitimate_address_p (MODE, X, 0)) goto ADDR;
4856 +#endif
4857 +
4858 +/* Try machine-dependent ways of modifying an illegitimate address
4859 +   to be legitimate.  If we find one, return the new, valid address.
4860 +   This macro is used in only one place: `memory_address' in explow.c.
4861 +
4862 +   OLDX is the address as it was before break_out_memory_refs was called.
4863 +   In some cases it is useful to look at this to decide what needs to be done.
4864 +
4865 +   MODE and WIN are passed so that this macro can use
4866 +   GO_IF_LEGITIMATE_ADDRESS.
4867 +
4868 +   It is always safe for this macro to do nothing.  It exists to recognize
4869 +   opportunities to optimize the output.
4870 +
4871 +   On RS/6000, first check for the sum of a register with a constant
4872 +   integer that is out of range.  If so, generate code to add the
4873 +   constant with the low-order 16 bits masked to the register and force
4874 +   this result into another register (this can be done with `cau').
4875 +   Then generate an address of REG+(CONST&0xffff), allowing for the
4876 +   possibility of bit 16 being a one.
4877 +
4878 +   Then check for the sum of a register and something not constant, try to
4879 +   load the other things into a register and return the sum.  */
4880 +
4881 +#define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN)                         \
4882 +{                                                                      \
4883 +   rtx result = ubicom32_legitimize_address ((X), (OLDX), (MODE));     \
4884 +   if (result != NULL_RTX)                                             \
4885 +     {                                                                 \
4886 +       (X) = result;                                                   \
4887 +       goto WIN;                                                       \
4888 +     }                                                                 \
4889 +}
4890 +
4891 +/* Try a machine-dependent way of reloading an illegitimate address
4892 +   operand.  If we find one, push the reload and jump to WIN.  This
4893 +   macro is used in only one place: `find_reloads_address' in reload.c.  */
4894 +#define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN)     \
4895 +{                                                                      \
4896 +  rtx new_rtx = ubicom32_legitimize_reload_address ((AD), (MODE), (OPNUM), (int)(TYPE));       \
4897 +  if (new_rtx)                                                         \
4898 +    {                                                                  \
4899 +      (AD) = new_rtx;                                                  \
4900 +      goto WIN;                                                                \
4901 +    }                                                                  \
4902 +}
4903 +
4904 +/* A C statement or compound statement with a conditional `goto LABEL;'
4905 +   executed if memory address X (an RTX) can have different meanings depending
4906 +   on the machine mode of the memory reference it is used for or if the address
4907 +   is valid for some modes but not others.
4908 +
4909 +   Autoincrement and autodecrement addresses typically have mode-dependent
4910 +   effects because the amount of the increment or decrement is the size of the
4911 +   operand being addressed.  Some machines have other mode-dependent addresses.
4912 +   Many RISC machines have no mode-dependent addresses.
4913 +
4914 +   You may assume that ADDR is a valid address for the machine.  */
4915 +#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)      \
4916 +  if (ubicom32_mode_dependent_address_p (ADDR))                \
4917 +    goto LABEL;
4918 +
4919 +/* A C expression that is nonzero if X is a legitimate constant for an
4920 +   immediate operand on the target machine.  You can assume that X
4921 +   satisfies `CONSTANT_P', so you need not check this.  In fact, `1' is
4922 +   a suitable definition for this macro on machines where anything
4923 +   `CONSTANT_P' is valid.  */
4924 +#define LEGITIMATE_CONSTANT_P(X) \
4925 +  ubicom32_legitimate_constant_p ((X))
4926 +
4927 +/* Moves between registers are pretty-much single instructions for
4928 +   Ubicom32.  We make this the default "2" that gcc likes.  */
4929 +#define REGISTER_MOVE_COST(MODE, FROM, TO) 2
4930 +
4931 +/* This is a little bit of magic from the S390 port that wins 2% on code
4932 +   size when building the Linux kernel!  Unfortunately while it wins on
4933 +   that size the user-space apps built using FD-PIC don't improve and the
4934 +   performance is lower because we put more pressure on the caches.  We may
4935 +   want this back on some future CPU that has higher cache performance.  */
4936 +/* #define IRA_HARD_REGNO_ADD_COST_MULTIPLIER(regno) 0.5 */
4937 +
4938 +/* Moves between registers and memory are more expensive than between
4939 +   registers because we have caches and write buffers that slow things
4940 +   down!  */
4941 +#define MEMORY_MOVE_COST(MODE, CLASS, IN) 2
4942 +
4943 +/* A fall-through branch is very low cost but anything that changes the PC
4944 +   incurs a major pipeline hazard.  We don't make the full extent of this
4945 +   hazard visible because we hope that multiple threads will absorb much
4946 +   of the cost and so we don't want a jump being replaced with, say, 7
4947 +   instructions.  */
4948 +#define BRANCH_COST(SPEED_P, PREDICTABLE_P) \
4949 +  ((PREDICTABLE_P) ? 1 : 3)
4950 +
4951 +/* Define this macro as a C expression which is nonzero if accessing less than
4952 +   a word of memory (i.e. a `char' or a `short') is no faster than accessing a
4953 +   word of memory, i.e., if such access require more than one instruction or if
4954 +   there is no difference in cost between byte and (aligned) word loads.
4955 +
4956 +   When this macro is not defined, the compiler will access a field by finding
4957 +   the smallest containing object; when it is defined, a fullword load will be
4958 +   used if alignment permits.  Unless bytes accesses are faster than word
4959 +   accesses, using word accesses is preferable since it may eliminate
4960 +   subsequent memory access if subsequent accesses occur to other fields in the
4961 +   same word of the structure, but to different bytes.  */
4962 +#define SLOW_BYTE_ACCESS 0
4963 +
4964 +/* The number of scalar move insns which should be generated instead of a
4965 +   string move insn or a library call.  Increasing the value will always make
4966 +   code faster, but eventually incurs high cost in increased code size.
4967 +
4968 +   If you don't define this, a reasonable default is used.  */
4969 +/* According to expr.c, a value of around 6 should minimize code size.  */
4970 +#define MOVE_RATIO(SPEED) 6
4971 +
4972 +/* We're much better off calling a constant function address with the
4973 +   Ubicom32 architecture because we have an opcode for doing so.  Don't
4974 +   let the compiler extract function addresses as common subexpressions
4975 +   into an address register.  */
4976 +#define NO_FUNCTION_CSE
4977 +
4978 +#define SELECT_CC_MODE(OP, X, Y) ubicom32_select_cc_mode (OP, X, Y)
4979 +
4980 +#define REVERSIBLE_CC_MODE(MODE) 1
4981 +
4982 +/* Canonicalize a comparison from one we don't have to one we do have.  */
4983 +#define CANONICALIZE_COMPARISON(CODE, OP0, OP1) \
4984 +  ubicom32_canonicalize_comparison (&(CODE), &(OP0), &(OP1))
4985 +
4986 +/* Dividing the output into sections.  */
4987 +
4988 +/* A C expression whose value is a string containing the assembler operation
4989 +   that should precede instructions and read-only data.  Normally `".text"' is
4990 +   right.  */
4991 +#define TEXT_SECTION_ASM_OP "\t.section .text"
4992 +
4993 +/* A C expression whose value is a string containing the assembler operation to
4994 +   identify the following data as writable initialized data.  Normally
4995 +   `".data"' is right.  */
4996 +#define DATA_SECTION_ASM_OP "\t.section .data"
4997 +
4998 +
4999 +/* If defined, a C expression whose value is a string containing the
5000 +   assembler operation to identify the following data as
5001 +   uninitialized global data.  If not defined, and neither
5002 +   `ASM_OUTPUT_BSS' nor `ASM_OUTPUT_ALIGNED_BSS' are defined,
5003 +   uninitialized global data will be output in the data section if
5004 +   `-fno-common' is passed, otherwise `ASM_OUTPUT_COMMON' will be
5005 +   used.  */
5006 +#define BSS_SECTION_ASM_OP "\t.section .bss"
5007 +
5008 +/* This is how we tell the assembler that a symbol is weak.  */
5009 +
5010 +#define ASM_WEAKEN_LABEL(FILE, NAME)   \
5011 +  do                                   \
5012 +    {                                  \
5013 +      fputs ("\t.weak\t", (FILE));     \
5014 +      assemble_name ((FILE), (NAME));  \
5015 +      fputc ('\n', (FILE));            \
5016 +    }                                  \
5017 +  while (0)
5018 +
5019 +/* The Overall Framework of an Assembler File.  */
5020 +
5021 +#undef SET_ASM_OP
5022 +#define SET_ASM_OP "\t.set\t"
5023 +
5024 +/* A C string constant describing how to begin a comment in the target
5025 +   assembler language.  The compiler assumes that the comment will end at the
5026 +   end of the line.  */
5027 +#define ASM_COMMENT_START ";"
5028 +
5029 +/* A C string constant for text to be output before each `asm' statement or
5030 +   group of consecutive ones.  Normally this is `"#APP"', which is a comment
5031 +   that has no effect on most assemblers but tells the GNU assembler that it
5032 +   must check the lines that follow for all valid assembler constructs.  */
5033 +#define ASM_APP_ON "#APP\n"
5034 +
5035 +/* A C string constant for text to be output after each `asm' statement or
5036 +   group of consecutive ones.  Normally this is `"#NO_APP"', which tells the
5037 +   GNU assembler to resume making the time-saving assumptions that are valid
5038 +   for ordinary compiler output.  */
5039 +#define ASM_APP_OFF "#NO_APP\n"
5040 +
5041 +/* Like `ASM_OUTPUT_BSS' except takes the required alignment as a separate,
5042 +   explicit argument.  If you define this macro, it is used in place of
5043 +   `ASM_OUTPUT_BSS', and gives you more flexibility in handling the required
5044 +   alignment of the variable.  The alignment is specified as the number of
5045 +   bits.
5046 +
5047 +   Try to use function `asm_output_aligned_bss' defined in file `varasm.c' when
5048 +   defining this macro.  */
5049 +#define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN) \
5050 +  asm_output_aligned_bss ((FILE), (DECL), (NAME), (SIZE), (ALIGN))
5051 +
5052 +/* A C expression to assign to OUTVAR (which is a variable of type `char *') a
5053 +   newly allocated string made from the string NAME and the number NUMBER, with
5054 +   some suitable punctuation added.  Use `alloca' to get space for the string.
5055 +
5056 +   The string will be used as an argument to `ASM_OUTPUT_LABELREF' to produce
5057 +   an assembler label for an internal static variable whose name is NAME.
5058 +   Therefore, the string must be such as to result in valid assembler code.
5059 +   The argument NUMBER is different each time this macro is executed; it
5060 +   prevents conflicts between similarly-named internal static variables in
5061 +   different scopes.
5062 +
5063 +   Ideally this string should not be a valid C identifier, to prevent any
5064 +   conflict with the user's own symbols.  Most assemblers allow periods or
5065 +   percent signs in assembler symbols; putting at least one of these between
5066 +   the name and the number will suffice.  */
5067 +#define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
5068 +  ((OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),  \
5069 +   sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO)))
5070 +
5071 +#define ASM_GENERATE_INTERNAL_LABEL(STRING, PREFIX, NUM)       \
5072 +  sprintf (STRING, "*.%s%ld", PREFIX, (long)(NUM))
5073 +/* A C statement to store into the string STRING a label whose name
5074 +   is made from the string PREFIX and the number NUM.
5075 +
5076 +   This string, when output subsequently by `assemble_name', should
5077 +   produce the output that `(*targetm.asm_out.internal_label)' would produce
5078 +   with the same PREFIX and NUM.
5079 +
5080 +   If the string begins with `*', then `assemble_name' will output
5081 +   the rest of the string unchanged.  It is often convenient for
5082 +   `ASM_GENERATE_INTERNAL_LABEL' to use `*' in this way.  If the
5083 +   string doesn't start with `*', then `ASM_OUTPUT_LABELREF' gets to
5084 +   output the string, and may change it.  (Of course,
5085 +   `ASM_OUTPUT_LABELREF' is also part of your machine description, so
5086 +   you should know what it does on your machine.)  */
5087 +
5088 +/* This says how to output assembler code to declare an
5089 +   uninitialized external linkage data object.  Under SVR4,
5090 +   the linker seems to want the alignment of data objects
5091 +   to depend on their types.  We do exactly that here.  */
5092 +
5093 +#define COMMON_ASM_OP  "\t.comm\t"
5094 +
5095 +#undef  ASM_OUTPUT_COMMON
5096 +#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)           \
5097 +  do                                                           \
5098 +    {                                                          \
5099 +      fprintf ((FILE), "%s", COMMON_ASM_OP);                   \
5100 +      assemble_name ((FILE), (NAME));                          \
5101 +      fprintf ((FILE), ", %u\n", (SIZE));                      \
5102 +    }                                                          \
5103 +  while (0)
5104 +
5105 +/* This says how to output assembler code to declare an
5106 +   uninitialized internal linkage data object.  Under SVR4,
5107 +   the linker seems to want the alignment of data objects
5108 +   to depend on their types.  We do exactly that here.  */
5109 +#define LOCAL_ASM_OP   "\t.lcomm\t"
5110 +
5111 +#undef  ASM_OUTPUT_LOCAL
5112 +#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)            \
5113 +  do                                                           \
5114 +    {                                                          \
5115 +      fprintf ((FILE), "%s", LOCAL_ASM_OP);                    \
5116 +      assemble_name ((FILE), (NAME));                          \
5117 +      fprintf ((FILE), ", %u\n", (SIZE));                      \
5118 +    }                                                          \
5119 +  while (0)
5120 +
5121 +/* Globalizing directive for a label.  */
5122 +#define GLOBAL_ASM_OP ".global\t"
5123 +
5124 +/* Output the operand of an instruction.  */
5125 +#define PRINT_OPERAND(FILE, X, CODE) \
5126 +  ubicom32_print_operand(FILE, X, CODE)
5127 +
5128 +/* Output the address of an operand.  */
5129 +#define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
5130 +  ubicom32_print_operand_address (FILE, ADDR)
5131 +
5132 +/* A C expression to output to STREAM some assembler code which will push hard
5133 +   register number REGNO onto the stack.  The code need not be optimal, since
5134 +   this macro is used only when profiling.  */
5135 +#define ASM_OUTPUT_REG_PUSH(FILE, REGNO)
5136 +
5137 +/* A C expression to output to STREAM some assembler code which will pop hard
5138 +   register number REGNO off of the stack.  The code need not be optimal, since
5139 +   this macro is used only when profiling.  */
5140 +#define ASM_OUTPUT_REG_POP(FILE, REGNO)
5141 +
5142 +/* This macro should be provided on machines where the addresses in a dispatch
5143 +   table are relative to the table's own address.
5144 +
5145 +   The definition should be a C statement to output to the stdio stream STREAM
5146 +   an assembler pseudo-instruction to generate a difference between two labels.
5147 +   VALUE and REL are the numbers of two internal labels.  The definitions of
5148 +   these labels are output using `ASM_OUTPUT_INTERNAL_LABEL', and they must be
5149 +   printed in the same way here.  For example,
5150 +
5151 +       fprintf (STREAM, "\t.word L%d-L%d\n", VALUE, REL)  */
5152 +#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
5153 +  fprintf (FILE, "\t%s .L%d-.L%d\n", ".long", VALUE, REL)
5154 +
5155 +/* This macro should be provided on machines where the addresses in a dispatch
5156 +   table are absolute.
5157 +
5158 +   The definition should be a C statement to output to the stdio stream STREAM
5159 +   an assembler pseudo-instruction to generate a reference to a label.  VALUE
5160 +   is the number of an internal label whose definition is output using
5161 +   `ASM_OUTPUT_INTERNAL_LABEL'.  For example,
5162 +
5163 +       fprintf (STREAM, "\t.word L%d\n", VALUE)  */
5164 +#define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
5165 +  fprintf (STREAM, "\t.word .L%d\n", VALUE)
5166 +
5167 +/* Switch into a generic section.  */
5168 +#define TARGET_ASM_NAMED_SECTION default_elf_asm_named_section
5169 +
5170 +/* Assembler Commands for Alignment.  */
5171 +
5172 +#define ASM_OUTPUT_SKIP(STREAM, N) fprintf (STREAM, "\t.skip %d,0\n", N)
5173 +/* A C statement to output to the stdio stream STREAM an assembler
5174 +   instruction to advance the location counter by NBYTES bytes.
5175 +   Those bytes should be zero when loaded.  NBYTES will be a C
5176 +   expression of type `int'.  */
5177 +
5178 +/* A C statement to output to the stdio stream STREAM an assembler command to
5179 +   advance the location counter to a multiple of 2 to the POWER bytes.  POWER
5180 +   will be a C expression of type `int'.  */
5181 +#define ASM_OUTPUT_ALIGN(FILE, LOG)    \
5182 +  if ((LOG) != 0)                      \
5183 +    fprintf (FILE, "\t.align %d\n", (LOG))
5184 +
5185 +/* A C expression that returns the DBX register number for the compiler
5186 +   register number REGNO.  In simple cases, the value of this expression may be
5187 +   REGNO itself.  But sometimes there are some registers that the compiler
5188 +   knows about and DBX does not, or vice versa.  In such cases, some register
5189 +   may need to have one number in the compiler and another for DBX.
5190 +
5191 +   If two registers have consecutive numbers inside GNU CC, and they can be
5192 +   used as a pair to hold a multiword value, then they *must* have consecutive
5193 +   numbers after renumbering with `DBX_REGISTER_NUMBER'.  Otherwise, debuggers
5194 +   will be unable to access such a pair, because they expect register pairs to
5195 +   be consecutive in their own numbering scheme.
5196 +
5197 +   If you find yourself defining `DBX_REGISTER_NUMBER' in way that does not
5198 +   preserve register pairs, then what you must do instead is redefine the
5199 +   actual register numbering scheme.
5200 +
5201 +   This declaration is required.  */
5202 +#define DBX_REGISTER_NUMBER(REGNO) REGNO
5203 +
5204 +/* A C expression that returns the integer offset value for an automatic
5205 +   variable having address X (an RTL expression).  The default computation
5206 +   assumes that X is based on the frame-pointer and gives the offset from the
5207 +   frame-pointer.  This is required for targets that produce debugging output
5208 +   for DBX or COFF-style debugging output for SDB and allow the frame-pointer
5209 +   to be eliminated when the `-g' options is used.  */
5210 +#define DEBUGGER_AUTO_OFFSET(X)                                                \
5211 +  ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)                   \
5212 +    + (frame_pointer_needed                                            \
5213 +       ? 0 : -initial_elimination_offset (FRAME_POINTER_REGNUM,                \
5214 +                                         STACK_POINTER_REGNUM)))
5215 +
5216 +/* A C expression that returns the integer offset value for an argument having
5217 +   address X (an RTL expression).  The nominal offset is OFFSET.  */
5218 +#define DEBUGGER_ARG_OFFSET(OFFSET, X)                                 \
5219 +  ((GET_CODE (X) == PLUS ? OFFSET : 0)                                 \
5220 +    + (frame_pointer_needed                                            \
5221 +       ? 0 : -initial_elimination_offset (ARG_POINTER_REGNUM,          \
5222 +                                         STACK_POINTER_REGNUM)))
5223 +
5224 +/* A C expression that returns the type of debugging output GNU CC produces
5225 +   when the user specifies `-g' or `-ggdb'.  Define this if you have arranged
5226 +   for GNU CC to support more than one format of debugging output.  Currently,
5227 +   the allowable values are `DBX_DEBUG', `SDB_DEBUG', `DWARF_DEBUG',
5228 +   `DWARF2_DEBUG', and `XCOFF_DEBUG'.
5229 +
5230 +   The value of this macro only affects the default debugging output; the user
5231 +   can always get a specific type of output by using `-gstabs', `-gcoff',
5232 +   `-gdwarf-1', `-gdwarf-2', or `-gxcoff'.
5233 +
5234 +   Defined in svr4.h.
5235 +*/
5236 +#undef PREFERRED_DEBUGGING_TYPE
5237 +#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
5238 +
5239 +/* Define this macro if GNU CC should produce dwarf version 2 format debugging
5240 +   output in response to the `-g' option.
5241 +
5242 +   To support optional call frame debugging information, you must also define
5243 +   `INCOMING_RETURN_ADDR_RTX' and either set `RTX_FRAME_RELATED_P' on the
5244 +   prologue insns if you use RTL for the prologue, or call `dwarf2out_def_cfa'
5245 +   and `dwarf2out_reg_save' as appropriate from `FUNCTION_PROLOGUE' if you
5246 +   don't.
5247 +
5248 +   Defined in svr4.h.  */
5249 +
5250 +#define DWARF2_DEBUGGING_INFO 1
5251 +/*#define DWARF2_UNWIND_INFO 1*/
5252 +#define DWARF2_UNWIND_INFO 0
5253 +#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, LINK_REGNO)
5254 +#define INCOMING_FRAME_SP_OFFSET 0
5255 +#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (LINK_REGNO)
5256 +#define EH_RETURN_FIRST 9
5257 +#define EH_RETURN_DATA_REGNO(N) ((N) < 2 ? (N) + EH_RETURN_FIRST : INVALID_REGNUM)
5258 +
5259 +/* The EH_RETURN_STACKADJ_RTX macro returns RTL which describes the
5260 +   location used to store the amount to ajdust the stack.  This is
5261 +   usually a registers that is available from end of the function's body
5262 +   to the end of the epilogue. Thus, this cannot be a register used as a
5263 +   temporary by the epilogue.
5264 +
5265 +   This must be an integer register.  */
5266 +#define EH_RETURN_STACKADJ_REGNO       11
5267 +#define EH_RETURN_STACKADJ_RTX         \
5268 +       gen_rtx_REG (Pmode, EH_RETURN_STACKADJ_REGNO)
5269 +
5270 +/* The EH_RETURN_HANDLER_RTX macro returns RTL which describes the
5271 +   location used to store the address the processor should jump to
5272 +   catch exception.  This is usually a registers that is available from
5273 +   end of the function's body to the end of the epilogue. Thus, this
5274 +   cannot be a register used as a temporary by the epilogue.
5275 +
5276 +   This must be an address register.  */
5277 +#define EH_RETURN_HANDLER_REGNO                18
5278 +#define EH_RETURN_HANDLER_RTX          \
5279 +       gen_rtx_REG (Pmode, EH_RETURN_HANDLER_REGNO)
5280 +
5281 +/* #define DWARF2_DEBUGGING_INFO */
5282 +
5283 +/* Define this macro if GNU CC should produce dwarf version 2-style
5284 +   line numbers.  This usually requires extending the assembler to
5285 +   support them, and #defining DWARF2_LINE_MIN_INSN_LENGTH in the
5286 +   assembler configuration header files.  */
5287 +/* #define DWARF2_ASM_LINE_DEBUG_INFO 1 */
5288 +
5289 +
5290 +/* An alias for a machine mode name.  This is the machine mode that elements
5291 +   of a jump-table have.  */
5292 +#define CASE_VECTOR_MODE Pmode
5293 +
5294 +/* Smallest number of different values for which it is best to use a
5295 +   jump-table instead of a tree of conditional branches.  For most Ubicom32
5296 +   targets this is quite small, but for the v1 architecture implementations
5297 +   we had very little data memory and so heavily prefer the tree approach
5298 +   rather than the jump tables.  */
5299 +#define CASE_VALUES_THRESHOLD ubicom32_case_values_threshold
5300 +
5301 +/* Register operations within the Ubicom32 architecture always operate on
5302 +   the whole register word and not just the sub-bits required for the opcode
5303 +   mode size.  */
5304 +#define WORD_REGISTER_OPERATIONS
5305 +
5306 +/* The maximum number of bytes that a single instruction can move quickly from
5307 +   memory to memory.  */
5308 +#define MOVE_MAX 4
5309 +
5310 +/* A C expression that is nonzero if on this machine the number of bits
5311 +   actually used for the count of a shift operation is equal to the number of
5312 +   bits needed to represent the size of the object being shifted.  When this
5313 +   macro is non-zero, the compiler will assume that it is safe to omit a
5314 +   sign-extend, zero-extend, and certain bitwise `and' instructions that
5315 +   truncates the count of a shift operation.  On machines that have
5316 +   instructions that act on bitfields at variable positions, which may include
5317 +   `bit test' instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables
5318 +   deletion of truncations of the values that serve as arguments to bitfield
5319 +   instructions.
5320 +
5321 +   If both types of instructions truncate the count (for shifts) and position
5322 +   (for bitfield operations), or if no variable-position bitfield instructions
5323 +   exist, you should define this macro.
5324 +
5325 +   However, on some machines, such as the 80386 and the 680x0, truncation only
5326 +   applies to shift operations and not the (real or pretended) bitfield
5327 +   operations.  Define `SHIFT_COUNT_TRUNCATED' to be zero on such machines.
5328 +   Instead, add patterns to the `md' file that include the implied truncation
5329 +   of the shift instructions.
5330 +
5331 +   You need not define this macro if it would always have the value of zero.  */
5332 +#define SHIFT_COUNT_TRUNCATED 1
5333 +
5334 +/* A C expression which is nonzero if on this machine it is safe to "convert"
5335 +   an integer of INPREC bits to one of OUTPREC bits (where OUTPREC is smaller
5336 +   than INPREC) by merely operating on it as if it had only OUTPREC bits.
5337 +
5338 +   On many machines, this expression can be 1.
5339 +
5340 +   When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for
5341 +   which `MODES_TIEABLE_P' is 0, suboptimal code can result.  If this is the
5342 +   case, making `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve
5343 +   things.  */
5344 +#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
5345 +
5346 +/* A C string constant that tells the GNU CC driver program options to pass
5347 +   to the assembler.  It can also specify how to translate options you give
5348 +   to GNU CC into options for GNU CC to pass to the assembler.  See the
5349 +   file `sun3.h' for an example of this.
5350 +
5351 +   Defined in svr4.h.  */
5352 +#undef ASM_SPEC
5353 +#define ASM_SPEC \
5354 +  "%{march=*:-m%*} %{!march=*:-mubicom32v4} %{mfdpic:-mfdpic}"
5355 +
5356 +#define LINK_SPEC "\
5357 +%{h*} %{v:-V} \
5358 +%{b} \
5359 +%{mfdpic:-melf32ubicom32fdpic -z text} \
5360 +%{static:-dn -Bstatic} \
5361 +%{shared:-G -Bdynamic} \
5362 +%{symbolic:-Bsymbolic} \
5363 +%{G*} \
5364 +%{YP,*} \
5365 +%{Qy:} %{!Qn:-Qy}"
5366 +
5367 +#undef STARTFILE_SPEC
5368 +#undef ENDFILE_SPEC
5369 +
5370 +/* The svr4.h LIB_SPEC with -leval and --*group tacked on */
5371 +
5372 +#undef  LIB_SPEC
5373 +#define LIB_SPEC "%{!shared:%{!symbolic:--start-group -lc -leval -lgcc --end-group}}"
5374 +
5375 +#undef HAVE_GAS_SHF_MERGE
5376 +#define HAVE_GAS_SHF_MERGE 0
5377 +
5378 +#define HANDLE_SYSV_PRAGMA 1
5379 +#undef HANDLE_PRAGMA_PACK
5380 +
5381 +typedef void (*ubicom32_func_ptr) (void);
5382 +
5383 +/* Define builtins for selected special-purpose instructions. */
5384 +enum ubicom32_builtins
5385 +{
5386 +  UBICOM32_BUILTIN_UBICOM32_SWAPB_2,
5387 +  UBICOM32_BUILTIN_UBICOM32_SWAPB_4
5388 +};
5389 +
5390 +extern rtx ubicom32_compare_op0;
5391 +extern rtx ubicom32_compare_op1;
5392 +
5393 +#define TYPE_ASM_OP    "\t.type\t"
5394 +#define TYPE_OPERAND_FMT       "@%s"
5395 +
5396 +#ifndef ASM_DECLARE_RESULT
5397 +#define ASM_DECLARE_RESULT(FILE, RESULT)
5398 +#endif
5399 +
5400 +/* These macros generate the special .type and .size directives which
5401 +   are used to set the corresponding fields of the linker symbol table
5402 +   entries in an ELF object file under SVR4.  These macros also output
5403 +   the starting labels for the relevant functions/objects.  */
5404 +
5405 +/* Write the extra assembler code needed to declare a function properly.
5406 +   Some svr4 assemblers need to also have something extra said about the
5407 +   function's return value.  We allow for that here.  */
5408 +
5409 +#ifndef ASM_DECLARE_FUNCTION_NAME
5410 +#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)            \
5411 +  do                                                           \
5412 +    {                                                          \
5413 +      ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "function");      \
5414 +      ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));           \
5415 +      ASM_OUTPUT_LABEL (FILE, NAME);                           \
5416 +    }                                                          \
5417 +  while (0)
5418 +#endif
5419 --- /dev/null
5420 +++ b/gcc/config/ubicom32/ubicom32.md
5421 @@ -0,0 +1,3753 @@
5422 +; GCC machine description for Ubicom32
5423 +;
5424 +; Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software
5425 +; Foundation, Inc.
5426 +; Contributed by Ubicom, Inc.
5427 +;
5428 +; This file is part of GCC.
5429 +;
5430 +; GCC is free software; you can redistribute it and/or modify
5431 +; it under the terms of the GNU General Public License as published by
5432 +; the Free Software Foundation; either version 3, or (at your option)
5433 +; any later version.
5434 +;
5435 +; GCC is distributed in the hope that it will be useful,
5436 +; but WITHOUT ANY WARRANTY; without even the implied warranty of
5437 +; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
5438 +; GNU General Public License for more details.
5439 +;
5440 +; You should have received a copy of the GNU General Public License
5441 +; along with GCC; see the file COPYING3.  If not see
5442 +; <http://www.gnu.org/licenses/>.
5443 +
5444 +(define_constants
5445 +  [(AUX_DATA_REGNO 15)
5446 +   (LINK_REGNO     21)
5447 +   (SP_REGNO       23)
5448 +   (ACC0_HI_REGNO  24)
5449 +   (ACC1_HI_REGNO  26)
5450 +   (CC_REGNO       30)])
5451 +
5452 +(define_constants
5453 +  [(UNSPEC_FDPIC_GOT 0)
5454 +   (UNSPEC_FDPIC_GOT_FUNCDESC 1)])
5455 +
5456 +(define_constants
5457 +  [(UNSPEC_VOLATILE_LOAD_FDPIC_FUNCDESC 0)])
5458 +
5459 +;; Types of instructions (for scheduling purposes).
5460 +
5461 +(define_attr "type" "mul,addr,other"
5462 +  (const_string "other"))
5463 +
5464 +; Define instruction scheduling characteristics.  We can only issue
5465 +; one instruction per clock so we don't need to define CPU units.
5466 +;
5467 +(define_automaton "ubicom32")
5468 +
5469 +(define_cpu_unit "i_pipeline" "ubicom32");
5470 +
5471 +; We have a 4 cycle hazard associated with address calculations which
5472 +; seems rather tricky to avoid so we go with a defensive assumption
5473 +; that almost anything can be used to generate addresses.
5474 +;
5475 +;(define_insn_reservation "ubicom32_other" 4
5476 +;                       (eq_attr "type" "other")
5477 +;                       "i_pipeline")
5478 +
5479 +; Some moves don't generate hazards.
5480 +;
5481 +;(define_insn_reservation "ubicom32_addr" 1
5482 +;                       (eq_attr "type" "addr")
5483 +;                       "i_pipeline")
5484 +
5485 +; We need 3 cycles between a multiply instruction and any use of the
5486 +; matching accumulator register(s).
5487 +;
5488 +(define_insn_reservation "ubicom32_mul" 4
5489 +                        (eq_attr "type" "mul")
5490 +                        "i_pipeline")
5491 +
5492 +(define_attr "length" ""
5493 +  (const_int 4))
5494 +
5495 +(include "predicates.md")
5496 +(include "constraints.md")
5497 +
5498 +; 8-bit move with no change to the flags reg.
5499 +;
5500 +(define_insn "movqi"
5501 +  [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
5502 +       (match_operand:QI 1 "ubicom32_move_operand"  "g"))]
5503 +  ""
5504 +  "move.1\\t%0, %1")
5505 +
5506 +; Combiner-generated 8-bit move with the zero flag set accordingly.
5507 +;
5508 +(define_insn "movqi_ccszn"
5509 +  [(set (reg CC_REGNO)
5510 +       (compare (match_operand:QI 0 "nonimmediate_operand" "rm")
5511 +                (const_int 0)))
5512 +   (set (match_operand:QI 1 "nonimmediate_operand"        "=rm")
5513 +       (match_dup 0))]
5514 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
5515 +  "ext.1\\t%1, %0")
5516 +
5517 +; Combine isn't very good at merging some types of operations so we
5518 +; have to make do with a peephole.  It's not as effective but it's better
5519 +; than doing nothing.
5520 +;
5521 +(define_peephole2
5522 +  [(set (match_operand:QI 0 "nonimmediate_operand" "")
5523 +       (match_operand:QI 1 "nonimmediate_operand" ""))
5524 +   (set (match_operand 2 "ubicom32_cc_register_operand" "")
5525 +       (match_operator 3 "ubicom32_compare_operator"
5526 +         [(match_dup 0)
5527 +          (const_int 0)]))]
5528 +  "(GET_MODE (operands[2]) == CCSZNmode
5529 +    || GET_MODE (operands[2]) == CCSZmode)"
5530 +  [(parallel
5531 +     [(set (match_dup 2)
5532 +          (match_op_dup 3
5533 +            [(match_dup 1)
5534 +             (const_int 0)]))
5535 +      (set (match_dup 0)
5536 +          (match_dup 1))])]
5537 +   "")
5538 +
5539 +; Combine isn't very good at merging some types of operations so we
5540 +; have to make do with a peephole.  It's not as effective but it's better
5541 +; than doing nothing.
5542 +;
5543 +(define_peephole2
5544 +  [(set (match_operand:QI 0 "nonimmediate_operand" "")
5545 +       (match_operand:QI 1 "nonimmediate_operand" ""))
5546 +   (set (match_operand 2 "ubicom32_cc_register_operand" "")
5547 +       (match_operator 3 "ubicom32_compare_operator"
5548 +         [(match_dup 1)
5549 +          (const_int 0)]))]
5550 +  "(GET_MODE (operands[2]) == CCSZNmode
5551 +    || GET_MODE (operands[2]) == CCSZmode)"
5552 +  [(parallel
5553 +     [(set (match_dup 2)
5554 +          (match_op_dup 3
5555 +            [(match_dup 1)
5556 +             (const_int 0)]))
5557 +      (set (match_dup 0)
5558 +          (match_dup 1))])]
5559 +   "")
5560 +
5561 +; 16-bit move with no change to the flags reg.
5562 +;
5563 +(define_insn "movhi"
5564 +  [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
5565 +       (match_operand:HI 1 "ubicom32_move_operand"  "g"))]
5566 +  ""
5567 +  "*
5568 +   {
5569 +     if (CONST_INT_P (operands[1]))
5570 +       return \"movei\\t%0, %1\";
5571 +
5572 +     return \"move.2\\t%0, %1\";
5573 +   }")
5574 +
5575 +; Combiner-generated 16-bit move with the zero flag set accordingly.
5576 +;
5577 +(define_insn "movhi_ccszn"
5578 +  [(set (reg CC_REGNO)
5579 +       (compare (match_operand:HI 0 "nonimmediate_operand" "rm")
5580 +                (const_int 0)))
5581 +   (set (match_operand:HI 1 "nonimmediate_operand"        "=rm")
5582 +       (match_dup 0))]
5583 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
5584 +  "ext.2\\t%1, %0")
5585 +
5586 +; Combine isn't very good at merging some types of operations so we
5587 +; have to make do with a peephole.  It's not as effective but it's better
5588 +; than doing nothing.
5589 +;
5590 +(define_peephole2
5591 +  [(set (match_operand:HI 0 "nonimmediate_operand" "")
5592 +       (match_operand:HI 1 "nonimmediate_operand" ""))
5593 +   (set (match_operand 2 "ubicom32_cc_register_operand" "")
5594 +       (match_operator 3 "ubicom32_compare_operator"
5595 +         [(match_dup 0)
5596 +          (const_int 0)]))]
5597 +  "(GET_MODE (operands[2]) == CCSZNmode
5598 +    || GET_MODE (operands[2]) == CCSZmode)"
5599 +  [(parallel
5600 +     [(set (match_dup 2)
5601 +          (match_op_dup 3
5602 +            [(match_dup 1)
5603 +             (const_int 0)]))
5604 +      (set (match_dup 0)
5605 +          (match_dup 1))])]
5606 +   "")
5607 +
5608 +; Combine isn't very good at merging some types of operations so we
5609 +; have to make do with a peephole.  It's not as effective but it's better
5610 +; than doing nothing.
5611 +;
5612 +(define_peephole2
5613 +  [(set (match_operand:HI 0 "nonimmediate_operand" "")
5614 +       (match_operand:HI 1 "nonimmediate_operand" ""))
5615 +   (set (match_operand 2 "ubicom32_cc_register_operand" "")
5616 +       (match_operator 3 "ubicom32_compare_operator"
5617 +         [(match_dup 1)
5618 +          (const_int 0)]))]
5619 +  "(GET_MODE (operands[2]) == CCSZNmode
5620 +    || GET_MODE (operands[2]) == CCSZmode)"
5621 +  [(parallel
5622 +     [(set (match_dup 2)
5623 +          (match_op_dup 3
5624 +            [(match_dup 1)
5625 +             (const_int 0)]))
5626 +      (set (match_dup 0)
5627 +          (match_dup 1))])]
5628 +   "")
5629 +
5630 +; 32-bit move with no change to the flags reg.
5631 +;
5632 +(define_expand "movsi"
5633 +  [(set (match_operand:SI 0 "nonimmediate_operand" "")
5634 +       (match_operand:SI 1 "general_operand" ""))]
5635 +  ""
5636 +  "{
5637 +     /* Convert any complexities in operand 1 into something that can just
5638 +        fall into the default expander code.  */
5639 +     ubicom32_expand_movsi (operands);
5640 +   }")
5641 +
5642 +(define_insn "movsi_high"
5643 +  [(set (match_operand:SI 0 "ubicom32_address_register_operand"                "=a")
5644 +       (high:SI (match_operand:SI 1 "ubicom32_symbolic_address_operand" "s")))]
5645 +  ""
5646 +  "moveai\\t%0, #%%hi(%E1)")
5647 +
5648 +(define_insn "movsi_lo_sum"
5649 +  [(set (match_operand:SI 0 "nonimmediate_operand"                      "=rm")
5650 +       (lo_sum:SI (match_operand:SI 1 "ubicom32_address_register_operand" "a")
5651 +                   (match_operand:SI 2 "immediate_operand"                "s")))]
5652 +  ""
5653 +  "lea.1\\t%0, %%lo(%E2)(%1)")
5654 +
5655 +(define_insn "movsi_internal"
5656 +  [(set (match_operand:SI 0 "nonimmediate_operand"   "=rm")
5657 +       (match_operand:SI 1 "ubicom32_move_operand" "rmnY"))]
5658 +  ""
5659 +  "*
5660 +   {
5661 +     if (CONST_INT_P (operands[1]))
5662 +       {
5663 +         ubicom32_emit_move_const_int (operands[0], operands[1]);
5664 +         return \"\";
5665 +       }
5666 +
5667 +     if (GET_CODE (operands[1]) == CONST_DOUBLE)
5668 +       {
5669 +         HOST_WIDE_INT i = CONST_DOUBLE_LOW (operands[1]);
5670 +
5671 +         ubicom32_emit_move_const_int (operands[0], GEN_INT (i));
5672 +         return \"\";
5673 +       }
5674 +
5675 +     if (ubicom32_address_register_operand (operands[0], VOIDmode)
5676 +        && register_operand (operands[1], VOIDmode))
5677 +       {
5678 +        if (ubicom32_address_register_operand (operands[1], VOIDmode))
5679 +          return \"lea.1\\t%0, 0(%1)\";
5680 +
5681 +        /* Use movea here to utilize the hazard bypass in the >= v4 ISA.  */
5682 +         if (ubicom32_v4)
5683 +          return \"movea\\t%0, %1\";
5684 +
5685 +         return \"move.4\\t%0, %1\";
5686 +       }
5687 +
5688 +     return \"move.4\\t%0, %1\";
5689 +   }")
5690 +
5691 +; If we're not dependent on the state of the condition codes we can construct
5692 +; constants of value 2^n by using a bset.
5693 +;
5694 +(define_peephole2
5695 +  [(set (match_operand:SI 0 "nonimmediate_operand" "")
5696 +       (match_operand:SI 1 "const_int_operand" ""))]
5697 +  "(exact_log2 (INTVAL (operands[1])) > 14
5698 +    && peep2_regno_dead_p (0, CC_REGNO))"
5699 +  [(parallel
5700 +     [(set (match_dup 0)
5701 +          (ior:SI (const_int 0)
5702 +                  (match_dup 1)))
5703 +      (clobber (reg:CC CC_REGNO))])]
5704 +  "")
5705 +
5706 +; If we're not dependent on the state of the condition codes we can construct
5707 +; constants of value ~(2^n) by using a bclr.
5708 +;
5709 +(define_peephole2
5710 +  [(set (match_operand:SI 0 "nonimmediate_operand" "")
5711 +       (match_operand:SI 1 "const_int_operand" ""))]
5712 +  "(exact_log2 (~INTVAL (operands[1])) > 14
5713 +    && peep2_regno_dead_p (0, CC_REGNO))"
5714 +  [(parallel
5715 +     [(set (match_dup 0)
5716 +          (and:SI (const_int -1)
5717 +                  (match_dup 1)))
5718 +      (clobber (reg:CC CC_REGNO))])]
5719 +  "")
5720 +
5721 +; For 32-bit constants that have bits 0 through 24 and bit 31 set the same
5722 +; we can use swapb.4!
5723 +;
5724 +(define_peephole2
5725 +  [(set (match_operand:SI 0 "nonimmediate_operand" "")
5726 +       (match_operand:SI 1 "const_int_operand" ""))]
5727 +  "(ubicom32_v4
5728 +    && (INTVAL (operands[1]) & 0xffffffff) != 0xffffffff
5729 +    && (INTVAL (operands[1]) & 0xffffffff) != 0
5730 +    && ((INTVAL (operands[1]) & 0x80ffffff) == 0
5731 +       || (INTVAL (operands[1]) & 0x80ffffff) == 0x80ffffff))"
5732 +  [(set (match_dup 0)
5733 +       (bswap:SI (match_dup 2)))]
5734 +  "{
5735 +     operands[2] = GEN_INT (INTVAL (operands[1]) >> 24);
5736 +   }")
5737 +
5738 +; If this is a write of a constant to memory look to see if we can usefully
5739 +; transform this into 2 smaller writes.
5740 +;
5741 +(define_peephole2
5742 +  [(set (match_operand:SI 0 "memory_operand" "")
5743 +       (match_operand:SI 1 "const_int_operand" ""))]
5744 +  "! satisfies_constraint_I (operands[1])
5745 +   && ubicom32_legitimate_address_p (HImode, plus_constant (XEXP (operands[0], 0), 2), 1)"
5746 +  [(set (match_dup 4) (match_dup 2))
5747 +   (set (match_dup 5) (match_dup 3))]
5748 +  "{
5749 +     rtx low_hword_addr;
5750 +
5751 +     operands[2] = gen_highpart_mode (HImode, SImode, operands[1]);
5752 +     operands[3] = gen_lowpart (HImode, operands[1]);
5753 +
5754 +     operands[4] = gen_rtx_MEM (HImode, XEXP (operands[0], 0));
5755 +     MEM_COPY_ATTRIBUTES (operands[4], operands[0]);
5756 +
5757 +     low_hword_addr = plus_constant (XEXP (operands[0], 0), 2);
5758 +     operands[5] = gen_rtx_MEM (HImode, low_hword_addr);
5759 +     MEM_COPY_ATTRIBUTES (operands[5], operands[0]);
5760 +   }")
5761 +
5762 +; If we're writing memory and we've not found a better way to do this then
5763 +; try loading into a D register and then copying to memory.  This will
5764 +; perform the fewest possible memory read/writes.
5765 +;
5766 +(define_peephole2
5767 +  [(match_scratch:SI 2 "d")
5768 +   (set (match_operand:SI 0 "memory_operand" "")
5769 +       (match_operand:SI 1 "const_int_operand" ""))]
5770 +  "! satisfies_constraint_I (operands[1])"
5771 +  [(set (match_dup 2) (match_dup 1))
5772 +   (set (match_dup 0) (match_dup 2))]
5773 +  "")
5774 +
5775 +; If we're not dependent on the state of the condition codes we can construct
5776 +; constants of value (2^n - 1) by using an lsr.4.
5777 +;
5778 +(define_peephole2
5779 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand" "")
5780 +       (match_operand:SI 1 "const_int_operand" ""))]
5781 +  "(exact_log2 (INTVAL (operands[1]) + 1) > 14
5782 +    && peep2_regno_dead_p (0, CC_REGNO))"
5783 +  [(parallel
5784 +     [(set (match_dup 0)
5785 +          (lshiftrt:SI (const_int -1)
5786 +                       (match_dup 2)))
5787 +      (clobber (reg:CC CC_REGNO))])]
5788 +  "{
5789 +     operands[2] = GEN_INT (32 - exact_log2 (INTVAL (operands[1]) + 1));
5790 +   }")
5791 +
5792 +; If we're not dependent on the state of the condition codes we can construct
5793 +; constants of value (2^n - 1) by using an lsr.4.
5794 +;
5795 +(define_peephole2
5796 +  [(match_scratch:SI 2 "d")
5797 +   (set (match_operand:SI 0 "nonimmediate_operand" "")
5798 +       (match_operand:SI 1 "const_int_operand" ""))]
5799 +  "(exact_log2 (INTVAL (operands[1]) + 1) > 14
5800 +    && peep2_regno_dead_p (0, CC_REGNO))"
5801 +  [(parallel
5802 +     [(set (match_dup 2)
5803 +          (lshiftrt:SI (const_int -1)
5804 +                       (match_dup 3)))
5805 +      (clobber (reg:CC CC_REGNO))])
5806 +   (set (match_dup 0)
5807 +       (match_dup 2))]
5808 +  "{
5809 +     operands[3] = GEN_INT (32 - exact_log2 (INTVAL (operands[1]) + 1));
5810 +   }")
5811 +
5812 +; If we're not dependent on the state of the condition codes we can construct
5813 +; some other constants by using an lsl.4 to shift 7 bits left by some
5814 +; constant.
5815 +;
5816 +(define_peephole2
5817 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand" "")
5818 +       (match_operand:SI 1 "const_int_operand" ""))]
5819 +  "(ubicom32_shiftable_const_int (INTVAL (operands[1]))
5820 +    && peep2_regno_dead_p (0, CC_REGNO))"
5821 +  [(parallel
5822 +     [(set (match_dup 0)
5823 +          (ashift:SI (match_dup 2)
5824 +                     (match_dup 3)))
5825 +      (clobber (reg:CC CC_REGNO))])]
5826 +  "{
5827 +     int shift = ubicom32_shiftable_const_int (INTVAL (operands[1]));
5828 +     operands[2] = GEN_INT (INTVAL (operands[1]) >> shift);
5829 +     operands[3] = GEN_INT (shift);
5830 +   }")
5831 +
5832 +; If we're not dependent on the state of the condition codes we can construct
5833 +; some other constants by using an lsl.4 to shift 7 bits left by some
5834 +; constant.
5835 +;
5836 +(define_peephole2
5837 +  [(match_scratch:SI 2 "d")
5838 +   (set (match_operand:SI 0 "nonimmediate_operand" "")
5839 +       (match_operand:SI 1 "const_int_operand" ""))]
5840 +  "(ubicom32_shiftable_const_int (INTVAL (operands[1]))
5841 +    && peep2_regno_dead_p (0, CC_REGNO))"
5842 +  [(parallel
5843 +     [(set (match_dup 2)
5844 +          (ashift:SI (match_dup 3)
5845 +                     (match_dup 4)))
5846 +      (clobber (reg:CC CC_REGNO))])
5847 +   (set (match_dup 0)
5848 +       (match_dup 2))]
5849 +  "{
5850 +     int shift = ubicom32_shiftable_const_int (INTVAL (operands[1]));
5851 +     operands[3] = GEN_INT (INTVAL (operands[1]) >> shift);
5852 +     operands[4] = GEN_INT (shift);
5853 +   }")
5854 +
5855 +; For some 16-bit unsigned constants that have bit 15 set we can use
5856 +; swapb.2!
5857 +;
5858 +; Note that the movsi code emits the same sequence but by using a peephole2
5859 +; we split the pattern early enough to allow instruction scheduling to
5860 +; occur.
5861 +;
5862 +(define_peephole2
5863 +  [(set (match_operand:SI 0 "register_operand" "")
5864 +       (match_operand:SI 1 "const_int_operand" ""))]
5865 +  "(ubicom32_v4
5866 +    && (INTVAL (operands[1]) & 0xffff80ff) == 0x80ff)"
5867 +  [(set (match_dup 0)
5868 +       (zero_extend:SI (bswap:HI (match_dup 2))))]
5869 +  "{
5870 +     HOST_WIDE_INT i = INTVAL (operands[1]) >> 8;
5871 +     if (i >= 0x80)
5872 +       i -= 0x100;
5873 +     operands[2] = GEN_INT (i);
5874 +   }")
5875 +
5876 +; In general for a 16-bit unsigned constant that has bit 15 set
5877 +; then we need a movei/move.2 pair unless we can represent it
5878 +; via just a move.2.
5879 +;
5880 +(define_peephole2
5881 +  [(set (match_operand:SI 0 "register_operand" "")
5882 +       (match_operand:SI 1 "const_int_operand" ""))]
5883 +  "(INTVAL (operands[1]) & 0xffff8000) == 0x8000
5884 +    && (INTVAL (operands[1]) & 0xffff) < 0xff80"
5885 +  [(set (match_dup 2)
5886 +       (match_dup 1))
5887 +   (set (match_dup 0)
5888 +       (zero_extend:SI (match_dup 2)))]
5889 +  "{
5890 +     operands[2] = gen_rtx_REG (HImode, REGNO (operands[0]));
5891 +   }")
5892 +
5893 +; If we're not dependent on the state of the condition codes we can construct
5894 +; 32-bit constants that have bits 16 through 31 set to arbitrary values
5895 +; and have bits 0 through 15 set to something representable as a default
5896 +; source-1 immediate - we use movei/shmrg.2
5897 +;
5898 +(define_peephole2
5899 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand" "")
5900 +       (match_operand:SI 1 "const_int_operand" ""))]
5901 +  "(((INTVAL (operands[1]) >= 0x8000
5902 +      && INTVAL (operands[1]) < 0xff80)
5903 +     || INTVAL (operands[1]) >= 0x10000
5904 +     || INTVAL (operands[1]) < -0x8000)
5905 +    && ((INTVAL (operands[1]) & 0xffff) >= 0xff80
5906 +       || (INTVAL (operands[1]) & 0xffff) < 0x80)
5907 +    && peep2_regno_dead_p (0, CC_REGNO))"
5908 +  [(set (match_dup 0)
5909 +       (match_dup 2))
5910 +   (parallel
5911 +     [(set (match_dup 0)
5912 +          (ior:SI
5913 +            (ashift:SI (match_dup 0)
5914 +                       (const_int 16))
5915 +            (zero_extend:SI
5916 +              (match_dup 3))))
5917 +      (clobber (reg:CC CC_REGNO))])]
5918 +  "{
5919 +     operands[2] = gen_highpart_mode (HImode, SImode, operands[1]);
5920 +     operands[3] = gen_lowpart (HImode, operands[1]);
5921 +   }")
5922 +
5923 +; Exactly the same as the peephole2 preceding except that this targets a
5924 +; general register instead of D register.  Hopefully the later optimization
5925 +; passes will notice that the value ended up in a D register first here
5926 +; and eliminate away the other register!
5927 +;
5928 +(define_peephole2
5929 +  [(match_scratch:SI 2 "d")
5930 +   (set (match_operand:SI 0 "register_operand" "")
5931 +       (match_operand:SI 1 "const_int_operand" ""))]
5932 +  "(((INTVAL (operands[1]) >= 0x8000
5933 +      && INTVAL (operands[1]) < 0xff80)
5934 +     || INTVAL (operands[1]) >= 0x10000
5935 +     || INTVAL (operands[1]) < -0x8000)
5936 +    && ((INTVAL (operands[1]) & 0xffff) >= 0xff80
5937 +       || (INTVAL (operands[1]) & 0xffff) < 0x80)
5938 +    && peep2_regno_dead_p (0, CC_REGNO))"
5939 +  [(set (match_dup 2)
5940 +       (match_dup 3))
5941 +   (parallel
5942 +     [(set (match_dup 2)
5943 +          (ior:SI
5944 +            (ashift:SI (match_dup 2)
5945 +                       (const_int 16))
5946 +            (zero_extend:SI
5947 +              (match_dup 4))))
5948 +      (clobber (reg:CC CC_REGNO))])
5949 +   (set (match_dup 0)
5950 +       (match_dup 2))]
5951 +  "{
5952 +     operands[3] = gen_highpart_mode (HImode, SImode, operands[1]);
5953 +     operands[4] = gen_lowpart (HImode, operands[1]);
5954 +   }")
5955 +
5956 +; If we have a load of a large integer constant which does not have bit 31
5957 +; set and we have a spare A reg then construct it with a moveai/lea.1 pair
5958 +; instead.  This avoids constructing it in 3 instructions on the stack.
5959 +;
5960 +; Note that we have to be careful not to match anything that matches
5961 +; something we can do in a single instruction!  There aren't many such
5962 +; constants but there are some.
5963 +;
5964 +(define_peephole2
5965 +  [(match_scratch:SI 2 "a")
5966 +   (set (match_operand:SI 0 "register_operand" "")
5967 +       (match_operand:SI 1 "const_int_operand" ""))]
5968 +  "(! (INTVAL (operands[1]) & 0x80000000)
5969 +    && ((INTVAL (operands[1]) >= 0x8000
5970 +        && INTVAL (operands[1]) < 0xff80)
5971 +       || INTVAL (operands[1]) >= 0x10000))"
5972 +  [(set (match_dup 2)
5973 +       (match_dup 3))
5974 +   (set (match_dup 0)
5975 +       (plus:SI (match_dup 2)
5976 +                (match_dup 4)))]
5977 +  "{
5978 +     HOST_WIDE_INT i = INTVAL (operands[1]);
5979 +     operands[3] = GEN_INT (i & 0xffffff80);
5980 +     operands[4] = GEN_INT (i & 0x7f);
5981 +   }")
5982 +
5983 +; If we're not dependent on the state of the condition codes we can construct
5984 +; a 32-bit constant with a movei/movei/shmrg.2 sequence if possible.
5985 +;
5986 +(define_peephole2
5987 +  [(match_scratch:HI 2 "d")
5988 +   (set (match_operand:SI 0 "ubicom32_data_register_operand" "")
5989 +       (match_operand:SI 1 "const_int_operand" ""))
5990 +   (match_dup 2)]
5991 +  "(INTVAL (operands[1]) & 0x80000000
5992 +    && INTVAL (operands[1]) < -0x8000
5993 +    && peep2_regno_dead_p (0, CC_REGNO))"
5994 +  [(set (match_dup 0)
5995 +       (match_dup 3))
5996 +   (set (match_dup 2)
5997 +       (match_dup 4))
5998 +   (parallel
5999 +     [(set (match_dup 0)
6000 +          (ior:SI
6001 +            (ashift:SI (match_dup 0)
6002 +                       (const_int 16))
6003 +            (zero_extend:SI
6004 +              (match_dup 2))))
6005 +      (clobber (reg:CC CC_REGNO))])]
6006 +  "{
6007 +     operands[3] = gen_highpart_mode (HImode, SImode, operands[1]);
6008 +     operands[4] = gen_lowpart (HImode, operands[1]);
6009 +   }")
6010 +
6011 +; Exactly the same as the peephole2 preceding except that this targets a
6012 +; general register instead of D register.  Hopefully the later optimization
6013 +; passes will notice that the value ended up in a D register first here
6014 +; and eliminate away the other register!
6015 +;
6016 +(define_peephole2
6017 +  [(match_scratch:SI 2 "d")
6018 +   (match_scratch:HI 3 "d")
6019 +   (set (match_operand:SI 0 "register_operand" "")
6020 +       (match_operand:SI 1 "const_int_operand" ""))
6021 +   (match_dup 3)]
6022 +  "(INTVAL (operands[1]) & 0x80000000
6023 +    && INTVAL (operands[1]) < -0x8000
6024 +    && peep2_regno_dead_p (0, CC_REGNO))"
6025 +  [(set (match_dup 2)
6026 +       (match_dup 4))
6027 +   (set (match_dup 3)
6028 +       (match_dup 5))
6029 +   (parallel
6030 +     [(set (match_dup 2)
6031 +          (ior:SI
6032 +            (ashift:SI (match_dup 2)
6033 +                       (const_int 16))
6034 +            (zero_extend:SI
6035 +              (match_dup 3))))
6036 +      (clobber (reg:CC CC_REGNO))])
6037 +   (set (match_dup 0)
6038 +       (match_dup 2))]
6039 +  "{
6040 +     operands[4] = gen_highpart_mode (HImode, SImode, operands[1]);
6041 +     operands[5] = gen_lowpart (HImode, operands[1]);
6042 +   }")
6043 +
6044 +(define_insn "movsi_fdpic_got_offset"
6045 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"   "=d")
6046 +       (match_operand:SI 1 "ubicom32_fdpic_got_offset_operand" "Y"))]
6047 +  ""
6048 +  "movei\\t%0, %1")
6049 +
6050 +; The explicit MEM inside the UNSPEC prevents the compiler from moving
6051 +; the load before a branch after a NULL test, or before a store that
6052 +; initializes a function descriptor.
6053 +
6054 +(define_insn_and_split "load_fdpic_funcdesc"
6055 +  [(set (match_operand:SI 0 "ubicom32_address_register_operand" "=a")
6056 +       (unspec_volatile:SI [(mem:SI (match_operand:SI 1 "address_operand" "p"))]
6057 +                            UNSPEC_VOLATILE_LOAD_FDPIC_FUNCDESC))]
6058 +  ""
6059 +  "#"
6060 +  "reload_completed"
6061 +  [(set (match_dup 0)
6062 +       (mem:SI (match_dup 1)))])
6063 +
6064 +; Combiner-generated 32-bit move with the zero flag set accordingly.
6065 +;
6066 +(define_insn "movsi_ccwzn"
6067 +  [(set (reg CC_REGNO)
6068 +       (compare (match_operand:SI 0 "nonimmediate_operand" "rm, d")
6069 +                (const_int 0)))
6070 +   (set (match_operand:SI 1 "nonimmediate_operand"         "=d,rm")
6071 +       (match_dup 0))]
6072 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
6073 +  "@
6074 +   lsl.4\\t%1, %0, #0
6075 +   add.4\\t%1, #0, %0")
6076 +
6077 +; Combiner-generated 32-bit move with all flags set accordingly.
6078 +;
6079 +(define_insn "movsi_ccw"
6080 +  [(set (reg CC_REGNO)
6081 +       (compare (match_operand:SI 0 "ubicom32_data_register_operand" "d")
6082 +                (const_int 0)))
6083 +   (set (match_operand:SI 1 "nonimmediate_operand"                 "=rm")
6084 +       (match_dup 0))]
6085 +  "ubicom32_match_cc_mode(insn, CCWmode)"
6086 +  "add.4\\t%1, #0, %0")
6087 +
6088 +; Combine isn't very good at merging some types of operations so we
6089 +; have to make do with a peephole.  It's not as effective but it's better
6090 +; than doing nothing.
6091 +;
6092 +(define_peephole2
6093 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand" "")
6094 +       (match_operand:SI 1 "nonimmediate_operand" ""))
6095 +   (parallel
6096 +     [(set (match_operand 2 "ubicom32_cc_register_operand" "")
6097 +          (match_operator 3 "ubicom32_compare_operator"
6098 +            [(match_dup 0)
6099 +             (const_int 0)]))
6100 +      (clobber (match_operand:SI 4 "ubicom32_data_register_operand" ""))])]
6101 +  "(GET_MODE (operands[2]) == CCWZNmode
6102 +    || GET_MODE (operands[2]) == CCWZmode)"
6103 +  [(parallel
6104 +     [(set (match_dup 2)
6105 +          (match_op_dup 3
6106 +            [(match_dup 1)
6107 +             (const_int 0)]))
6108 +      (set (match_dup 0)
6109 +          (match_dup 1))])]
6110 +   "")
6111 +
6112 +; Combine isn't very good at merging some types of operations so we
6113 +; have to make do with a peephole.  It's not as effective but it's better
6114 +; than doing nothing.
6115 +;
6116 +(define_peephole2
6117 +  [(set (match_operand:SI 0 "nonimmediate_operand" "")
6118 +       (match_operand:SI 1 "ubicom32_data_register_operand" ""))
6119 +   (parallel
6120 +     [(set (match_operand 2 "ubicom32_cc_register_operand" "")
6121 +          (match_operator 3 "ubicom32_compare_operator"
6122 +            [(match_dup 1)
6123 +             (const_int 0)]))
6124 +      (clobber (match_operand:SI 4 "ubicom32_data_register_operand" ""))])]
6125 +  "(GET_MODE (operands[2]) == CCWZNmode
6126 +    || GET_MODE (operands[2]) == CCWZmode)"
6127 +  [(parallel
6128 +     [(set (match_dup 2)
6129 +          (match_op_dup 3
6130 +            [(match_dup 1)
6131 +             (const_int 0)]))
6132 +      (set (match_dup 0)
6133 +          (match_dup 1))])]
6134 +   "")
6135 +
6136 +; Combine isn't very good at merging some types of operations so we
6137 +; have to make do with a peephole.  It's not as effective but it's better
6138 +; than doing nothing.
6139 +;
6140 +(define_peephole2
6141 +  [(set (match_operand:SI 0 "register_operand" "")
6142 +       (match_operand:SI 1 "nonimmediate_operand" ""))
6143 +   (parallel
6144 +     [(set (match_operand 2 "ubicom32_cc_register_operand" "")
6145 +          (match_operator 3 "ubicom32_compare_operator"
6146 +            [(match_dup 0)
6147 +             (const_int 0)]))
6148 +      (set (match_operand:SI 4 "ubicom32_data_register_operand" "")
6149 +          (match_dup 0))])]
6150 +  "(peep2_reg_dead_p (2, operands[0])
6151 +    && (GET_MODE (operands[2]) == CCWZNmode
6152 +       || GET_MODE (operands[2]) == CCWZmode))"
6153 +  [(parallel
6154 +     [(set (match_dup 2)
6155 +          (match_op_dup 3
6156 +            [(match_dup 1)
6157 +             (const_int 0)]))
6158 +      (set (match_dup 4)
6159 +          (match_dup 1))])]
6160 +   "")
6161 +
6162 +; Register renaming may make a general reg into a D reg in which case
6163 +; we may be able to simplify a compare.
6164 +;
6165 +(define_peephole2
6166 +  [(set (match_operand:SI 0 "register_operand" "")
6167 +       (match_operand:SI 1 "nonimmediate_operand" ""))
6168 +   (parallel
6169 +     [(set (match_operand 2 "ubicom32_cc_register_operand" "")
6170 +          (match_operator 3 "ubicom32_compare_operator"
6171 +            [(match_dup 0)
6172 +             (const_int 0)]))
6173 +      (clobber (match_operand:SI 4 "ubicom32_data_register_operand" ""))])]
6174 +  "(peep2_reg_dead_p (2, operands[0])
6175 +    && (GET_MODE (operands[2]) == CCWZNmode
6176 +       || GET_MODE (operands[2]) == CCWZmode))"
6177 +  [(parallel
6178 +     [(set (match_dup 2)
6179 +          (match_op_dup 3
6180 +            [(match_dup 1)
6181 +             (const_int 0)]))
6182 +      (clobber (match_dup 4))])]
6183 +   "")
6184 +
6185 +(define_insn_and_split "movdi"
6186 +  [(set (match_operand:DI 0 "nonimmediate_operand" "=r,rm")
6187 +       (match_operand:DI 1 "general_operand"     "rmi,ri"))]
6188 +  ""
6189 +  "#"
6190 +  "reload_completed"
6191 +  [(set (match_dup 2) (match_dup 3))
6192 +   (set (match_dup 4) (match_dup 5))]
6193 +  "{
6194 +     rtx dest_low;
6195 +     rtx src_low;
6196 +
6197 +     dest_low = gen_lowpart (SImode, operands[0]);
6198 +     src_low = gen_lowpart (SImode, operands[1]);
6199 +
6200 +     if (REG_P (operands[0])
6201 +        && REG_P (operands[1])
6202 +        && REGNO (operands[0]) < REGNO (operands[1]))
6203 +       {
6204 +        operands[2] = gen_highpart (SImode, operands[0]);
6205 +        operands[3] = gen_highpart_mode (SImode, DImode, operands[1]);
6206 +        operands[4] = dest_low;
6207 +        operands[5] = src_low;
6208 +       }
6209 +     else if (reg_mentioned_p (dest_low, src_low))
6210 +       {
6211 +        operands[2] = gen_highpart (SImode, operands[0]);
6212 +        operands[3] = gen_highpart_mode (SImode, DImode, operands[1]);
6213 +        operands[4] = dest_low;
6214 +        operands[5] = src_low;
6215 +       }
6216 +     else
6217 +       {
6218 +        operands[2] = dest_low;
6219 +        operands[3] = src_low;
6220 +        operands[4] = gen_highpart (SImode, operands[0]);
6221 +        operands[5] = gen_highpart_mode (SImode, DImode, operands[1]);
6222 +       }
6223 +   }"
6224 +  [(set_attr "length" "8")])
6225 +
6226 +; Combiner-generated 64-bit move with all flags set accordingly.
6227 +;
6228 +(define_insn "movdi_ccwzn"
6229 +  [(set (reg CC_REGNO)
6230 +       (compare (match_operand:DI 0 "nonimmediate_operand" "d, m,   r")
6231 +                (const_int 0)))
6232 +   (set (match_operand:DI 1 "nonimmediate_operand"      "=&rm,rm,!&rm")
6233 +       (match_dup 0))
6234 +   (clobber (match_scratch:SI 2                                   "=X, d,   d"))]
6235 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
6236 +  "*
6237 +   {
6238 +     operands[3] = gen_lowpart (SImode, operands[0]);
6239 +     operands[4] = gen_lowpart (SImode, operands[1]);
6240 +     operands[5] = gen_highpart (SImode, operands[0]);
6241 +     operands[6] = gen_highpart (SImode, operands[1]);
6242 +
6243 +     if (ubicom32_data_register_operand (operands[0], VOIDmode))
6244 +       return \"add.4\\t%4, #0, %3\;addc\\t%6, #0, %5\";
6245 +
6246 +     return \"movei\\t%2, #0\;add.4\\t%4, %3, %2\;addc\\t%6, %5, %2\";
6247 +   }"
6248 +  [(set_attr "length" "8")])
6249 +
6250 +(define_insn "movdi_ccw"
6251 +  [(set (reg CC_REGNO)
6252 +       (compare (match_operand:DI 0 "nonimmediate_operand" "d, m,   r")
6253 +                (const_int 0)))
6254 +   (set (match_operand:DI 1 "nonimmediate_operand"      "=&rm,rm,!&rm")
6255 +       (match_dup 0))
6256 +   (clobber (match_scratch:SI 2                                   "=X, d,   d"))]
6257 +  "ubicom32_match_cc_mode(insn, CCWmode)"
6258 +  "*
6259 +   {
6260 +     operands[3] = gen_lowpart (SImode, operands[0]);
6261 +     operands[4] = gen_lowpart (SImode, operands[1]);
6262 +     operands[5] = gen_highpart (SImode, operands[0]);
6263 +     operands[6] = gen_highpart (SImode, operands[1]);
6264 +
6265 +     if (ubicom32_data_register_operand (operands[0], VOIDmode))
6266 +       return \"add.4\\t%4, #0, %3\;addc\\t%6, #0, %5\";
6267 +
6268 +     return \"movei\\t%2, #0\;add.4\\t%4, %3, %2\;addc\\t%6, %5, %2\";
6269 +   }"
6270 +  [(set_attr "length" "8")])
6271 +
6272 +(define_insn "movsf"
6273 +  [(set (match_operand:SF 0 "nonimmediate_operand"  "=!d,*rm")
6274 +       (match_operand:SF 1 "ubicom32_move_operand" "rmF,rmF"))]
6275 +  ""
6276 +  "*
6277 +   {
6278 +     if (GET_CODE (operands[1]) == CONST_DOUBLE)
6279 +       {
6280 +        HOST_WIDE_INT val;
6281 +        REAL_VALUE_TYPE rv;
6282 +
6283 +        REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
6284 +        REAL_VALUE_TO_TARGET_SINGLE (rv, val);
6285 +
6286 +        ubicom32_emit_move_const_int (operands[0], GEN_INT (val));
6287 +        return \"\";
6288 +       }
6289 +
6290 +     return \"move.4\\t%0, %1\";
6291 +   }")
6292 +
6293 +(define_insn "zero_extendqihi2"
6294 +  [(set (match_operand:HI 0 "register_operand"                    "=r")
6295 +       (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "rm")))]
6296 +  ""
6297 +  "move.1\\t%0, %1")
6298 +
6299 +(define_insn "zero_extendqisi2"
6300 +  [(set (match_operand:SI 0 "register_operand"                    "=r")
6301 +       (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "rm")))]
6302 +  ""
6303 +  "move.1\\t%0, %1")
6304 +
6305 +(define_insn "zero_extendqisi2_ccwz_1"
6306 +  [(set (reg CC_REGNO)
6307 +       (compare
6308 +         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "rm"))
6309 +          (const_int 0)))
6310 +   (set (match_operand:SI 0 "ubicom32_data_register_operand"        "=d")
6311 +       (zero_extend:SI (match_dup 1)))]
6312 +  "ubicom32_match_cc_mode(insn, CCWZmode)"
6313 +  "shmrg.1\\t%0, %1, #0")
6314 +
6315 +(define_insn "zero_extendhisi2"
6316 +  [(set (match_operand:SI 0 "register_operand"                    "=r")
6317 +       (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")))]
6318 +  ""
6319 +  "move.2\\t%0, %1")
6320 +
6321 +(define_insn "zero_extendhisi2_ccwz_1"
6322 +  [(set (reg CC_REGNO)
6323 +       (compare
6324 +         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm"))
6325 +          (const_int 0)))
6326 +   (set (match_operand:SI 0 "ubicom32_data_register_operand"        "=d")
6327 +       (zero_extend:SI (match_dup 1)))]
6328 +  "ubicom32_match_cc_mode(insn, CCWZmode)"
6329 +  "shmrg.2\\t%0, %1, #0")
6330 +
6331 +(define_insn_and_split "zero_extendqidi2"
6332 +  [(set (match_operand:DI 0 "register_operand"                    "=r")
6333 +       (zero_extend:DI (match_operand:QI 1 "nonimmediate_operand" "rm")))]
6334 +  ""
6335 +  "#"
6336 +  "reload_completed"
6337 +  [(set (match_dup 2)
6338 +       (zero_extend:SI (match_dup 1)))
6339 +   (set (match_dup 3)
6340 +       (const_int 0))]
6341 +  "{
6342 +     operands[2] = gen_lowpart (SImode, operands[0]);
6343 +     operands[3] = gen_highpart (SImode, operands[0]);
6344 +   }"
6345 +  [(set_attr "length" "8")])
6346 +
6347 +(define_insn_and_split "zero_extendhidi2"
6348 +  [(set (match_operand:DI 0 "register_operand"                    "=r")
6349 +       (zero_extend:DI (match_operand:HI 1 "nonimmediate_operand" "rm")))]
6350 +  ""
6351 +  "#"
6352 +  "reload_completed"
6353 +  [(set (match_dup 2)
6354 +       (zero_extend:SI (match_dup 1)))
6355 +   (set (match_dup 3)
6356 +       (const_int 0))]
6357 +  "{
6358 +     operands[2] = gen_lowpart (SImode, operands[0]);
6359 +     operands[3] = gen_highpart (SImode, operands[0]);
6360 +   }"
6361 +  [(set_attr "length" "8")])
6362 +
6363 +(define_insn_and_split "zero_extendsidi2"
6364 +  [(set (match_operand:DI 0 "nonimmediate_operand"               "=rm")
6365 +       (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "rm")))]
6366 +  ""
6367 +  "#"
6368 +  "reload_completed"
6369 +  [(set (match_dup 2)
6370 +       (match_dup 1))
6371 +   (set (match_dup 3)
6372 +       (const_int 0))]
6373 +  "{
6374 +     operands[2] = gen_lowpart (SImode, operands[0]);
6375 +     operands[3] = gen_highpart (SImode, operands[0]);
6376 +   }"
6377 +  [(set_attr "length" "8")])
6378 +
6379 +(define_insn "extendqihi2"
6380 +  [(set (match_operand:HI 0 "register_operand"                    "=r")
6381 +       (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "rm")))
6382 +   (clobber (reg:CC CC_REGNO))]
6383 +  ""
6384 +  "ext.1\\t%0, %1")
6385 +
6386 +(define_insn "extendqisi2"
6387 +  [(set (match_operand:SI 0 "register_operand"                    "=r")
6388 +       (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "rm")))
6389 +   (clobber (reg:CC CC_REGNO))]
6390 +  ""
6391 +  "ext.1\\t%0, %1")
6392 +
6393 +(define_insn "extendhisi2"
6394 +  [(set (match_operand:SI 0 "register_operand"                    "=r")
6395 +       (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")))
6396 +   (clobber (reg:CC CC_REGNO))]
6397 +  ""
6398 +  "ext.2\\t%0, %1")
6399 +
6400 +(define_insn_and_split "extendsidi2"
6401 +  [(set (match_operand:DI 0 "nonimmediate_operand"                "=d")
6402 +       (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "rm")))
6403 +   (clobber (reg:CC CC_REGNO))]
6404 +  ""
6405 +  "#"
6406 +  "reload_completed"
6407 +  [(set (match_dup 2)
6408 +       (match_dup 1))
6409 +   (parallel
6410 +     [(set (match_dup 3)
6411 +          (ashiftrt:SI (match_dup 2)
6412 +                       (const_int 31)))
6413 +      (clobber (reg:CC CC_REGNO))])]
6414 +  "{
6415 +     operands[2] = gen_lowpart (SImode, operands[0]);
6416 +     operands[3] = gen_highpart (SImode, operands[0]);
6417 +   }"
6418 +  [(set_attr "length" "8")])
6419 +
6420 +(define_insn "bswaphi"
6421 +  [(set (match_operand:HI 0 "nonimmediate_operand"            "=rm")
6422 +       (bswap:HI (match_operand:HI 1 "ubicom32_arith_operand" "rmI")))]
6423 +  "(ubicom32_v4)"
6424 +  "swapb.2\\t%0, %1");
6425 +
6426 +(define_insn "bswaphisi"
6427 +  [(set (match_operand:SI 0 "register_operand"                   "=r")
6428 +       (zero_extend:SI
6429 +         (bswap:HI (match_operand:HI 1 "ubicom32_arith_operand" "rmI"))))]
6430 +  "(ubicom32_v4)"
6431 +  "swapb.2\\t%0, %1");
6432 +
6433 +(define_insn "bswapsi"
6434 +  [(set (match_operand:SI 0 "nonimmediate_operand"            "=rm")
6435 +       (bswap:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI")))]
6436 +  "(ubicom32_v4)"
6437 +  "swapb.4\\t%0, %1");
6438 +
6439 +(define_insn "tstqi_ext1"
6440 +  [(set (reg CC_REGNO)
6441 +       (compare (match_operand:QI 0 "nonimmediate_operand" "rm")
6442 +                (const_int 0)))]
6443 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
6444 +  "ext.1\\t#0, %0")
6445 +
6446 +(define_expand "cmpqi"
6447 +  [(set (reg CC_REGNO)
6448 +       (compare (match_operand:QI 0 "ubicom32_arith_operand" "")
6449 +                (match_operand:QI 1 "ubicom32_data_register_operand" "")))]
6450 +  "(ubicom32_v4)"
6451 +  "{
6452 +     ubicom32_compare_op0 = operands[0];
6453 +     ubicom32_compare_op1 = operands[1];
6454 +     DONE;
6455 +   }")
6456 +
6457 +(define_insn "sub1_ccs"
6458 +  [(set (reg CC_REGNO)
6459 +       (compare (match_operand:QI 0 "ubicom32_arith_operand"       "rmI")
6460 +                (match_operand:QI 1 "ubicom32_data_register_operand" "d")))]
6461 +  "(ubicom32_v4)"
6462 +  "sub.1\\t#0, %0, %1")
6463 +
6464 +; If we're testing for equality we don't have to worry about reversing conditions.
6465 +;
6466 +(define_insn "sub1_ccsz_1"
6467 +  [(set (reg:CCSZ CC_REGNO)
6468 +       (compare:CCSZ (match_operand:QI 0 "nonimmediate_operand"          "rm")
6469 +                     (match_operand:QI 1 "ubicom32_data_register_operand" "d")))]
6470 +  "(ubicom32_v4)"
6471 +  "sub.1\\t#0, %0, %1")
6472 +
6473 +(define_insn "sub1_ccsz_2"
6474 +  [(set (reg:CCSZ CC_REGNO)
6475 +       (compare:CCSZ (match_operand:QI 0 "ubicom32_data_register_operand" "d")
6476 +                     (match_operand:QI 1 "ubicom32_arith_operand"       "rmI")))]
6477 +  "(ubicom32_v4)"
6478 +  "sub.1\\t#0, %1, %0")
6479 +
6480 +; When the combiner runs it doesn't have any insight into whether or not an argument
6481 +; to a compare is spilled to the stack and therefore can't swap the comparison in
6482 +; an attempt to use sub.1 more effectively.  We peephole this case here.
6483 +;
6484 +(define_peephole2
6485 +  [(set (match_operand:QI 0 "register_operand" "")
6486 +       (match_operand:QI 1 "ubicom32_arith_operand" ""))
6487 +   (set (match_operand 2 "ubicom32_cc_register_operand" "")
6488 +       (compare (match_operand:QI 3 "ubicom32_data_register_operand" "")
6489 +                (match_dup 0)))
6490 +   (set (pc)
6491 +       (if_then_else (match_operator 4 "comparison_operator"
6492 +                       [(match_dup 2)
6493 +                        (const_int 0)])
6494 +                     (label_ref (match_operand 5 "" ""))
6495 +                     (pc)))]
6496 +  "(peep2_reg_dead_p (2, operands[0])
6497 +    && peep2_regno_dead_p (3, CC_REGNO))"
6498 +  [(set (match_dup 2)
6499 +       (compare (match_dup 1)
6500 +                (match_dup 3)))
6501 +   (set (pc)
6502 +       (if_then_else (match_op_dup 6
6503 +                       [(match_dup 2)
6504 +                        (const_int 0)])
6505 +                     (label_ref (match_dup 5))
6506 +                     (pc)))]
6507 +  "{
6508 +     rtx cc_reg;
6509 +
6510 +     cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO);
6511 +     operands[6] = gen_rtx_fmt_ee (swap_condition (GET_CODE (operands[4])),
6512 +                                  GET_MODE (operands[4]),
6513 +                                  cc_reg,
6514 +                                  const0_rtx);
6515 +   }")
6516 +
6517 +(define_insn "tsthi_ext2"
6518 +  [(set (reg CC_REGNO)
6519 +       (compare (match_operand:HI 0 "nonimmediate_operand" "rm")
6520 +                (const_int 0)))]
6521 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
6522 +  "ext.2\\t#0, %0")
6523 +
6524 +(define_expand "cmphi"
6525 +  [(set (reg CC_REGNO)
6526 +       (compare (match_operand:HI 0 "ubicom32_arith_operand" "")
6527 +                (match_operand:HI 1 "ubicom32_compare_operand" "")))]
6528 +  ""
6529 +  "{
6530 +     do
6531 +       {
6532 +        /* Is this a cmpi? */
6533 +        if (CONST_INT_P (operands[1]))
6534 +          break;
6535 +
6536 +        /* Must be a sub.2 - if necessary copy an operand into a reg.  */
6537 +        if (! ubicom32_data_register_operand (operands[1], HImode))
6538 +          operands[1] = copy_to_mode_reg (HImode, operands[1]);
6539 +       }
6540 +     while (0);
6541 +
6542 +     ubicom32_compare_op0 = operands[0];
6543 +     ubicom32_compare_op1 = operands[1];
6544 +     DONE;
6545 +   }")
6546 +
6547 +(define_insn "cmpi"
6548 +  [(set (reg CC_REGNO)
6549 +       (compare (match_operand:HI 0 "nonimmediate_operand" "rm")
6550 +                (match_operand 1 "const_int_operand"        "N")))]
6551 +  ""
6552 +  "cmpi\\t%0, %1")
6553 +
6554 +(define_insn "sub2_ccs"
6555 +  [(set (reg CC_REGNO)
6556 +       (compare (match_operand:HI 0 "ubicom32_arith_operand"       "rmI")
6557 +                (match_operand:HI 1 "ubicom32_data_register_operand" "d")))]
6558 +  ""
6559 +  "sub.2\\t#0, %0, %1")
6560 +
6561 +; If we're testing for equality we don't have to worry about reversing conditions.
6562 +;
6563 +(define_insn "sub2_ccsz_1"
6564 +  [(set (reg:CCSZ CC_REGNO)
6565 +       (compare:CCSZ (match_operand:HI 0 "nonimmediate_operand"          "rm")
6566 +                     (match_operand:HI 1 "ubicom32_data_register_operand" "d")))]
6567 +  ""
6568 +  "sub.2\\t#0, %0, %1")
6569 +
6570 +(define_insn "sub2_ccsz_2"
6571 +  [(set (reg:CCSZ CC_REGNO)
6572 +       (compare:CCSZ (match_operand:HI 0 "ubicom32_data_register_operand" "d")
6573 +                     (match_operand:HI 1 "ubicom32_arith_operand"       "rmI")))]
6574 +  ""
6575 +  "sub.2\\t#0, %1, %0")
6576 +
6577 +; When the combiner runs it doesn't have any insight into whether or not an argument
6578 +; to a compare is spilled to the stack and therefore can't swap the comparison in
6579 +; an attempt to use sub.2 more effectively.  We peephole this case here.
6580 +;
6581 +(define_peephole2
6582 +  [(set (match_operand:HI 0 "register_operand" "")
6583 +       (match_operand:HI 1 "ubicom32_arith_operand" ""))
6584 +   (set (match_operand 2 "ubicom32_cc_register_operand" "")
6585 +       (compare (match_operand:HI 3 "ubicom32_data_register_operand" "")
6586 +                (match_dup 0)))
6587 +   (set (pc)
6588 +       (if_then_else (match_operator 4 "comparison_operator"
6589 +                       [(match_dup 2)
6590 +                        (const_int 0)])
6591 +                     (label_ref (match_operand 5 "" ""))
6592 +                     (pc)))]
6593 +  "(peep2_reg_dead_p (2, operands[0])
6594 +    && peep2_regno_dead_p (3, CC_REGNO))"
6595 +  [(set (match_dup 2)
6596 +       (compare (match_dup 1)
6597 +                (match_dup 3)))
6598 +   (set (pc)
6599 +       (if_then_else (match_op_dup 6
6600 +                       [(match_dup 2)
6601 +                        (const_int 0)])
6602 +                     (label_ref (match_dup 5))
6603 +                     (pc)))]
6604 +  "{
6605 +     rtx cc_reg;
6606 +
6607 +     cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO);
6608 +     operands[6] = gen_rtx_fmt_ee (swap_condition (GET_CODE (operands[4])),
6609 +                                  GET_MODE (operands[4]),
6610 +                                  cc_reg,
6611 +                                  const0_rtx);
6612 +   }")
6613 +
6614 +(define_insn_and_split "tstsi_lsl4"
6615 +  [(set (match_operand 0 "ubicom32_cc_register_operand" "=r")
6616 +       (match_operator 1 "ubicom32_compare_operator"
6617 +         [(match_operand:SI 2 "nonimmediate_operand"   "rm")
6618 +          (const_int 0)]))]
6619 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
6620 +  "#"
6621 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
6622 +  [(parallel
6623 +     [(set (match_dup 0)
6624 +          (match_op_dup 1
6625 +            [(match_dup 2)
6626 +             (const_int 0)]))
6627 +      (clobber (match_dup 3))])]
6628 +  "{
6629 +     operands[3] = gen_reg_rtx (SImode);
6630 +   }")
6631 +
6632 +(define_insn "tstsi_lsl4_d"
6633 +  [(set (reg CC_REGNO)
6634 +       (compare (match_operand:SI 0 "nonimmediate_operand" "rm")
6635 +                (const_int 0)))
6636 +   (clobber (match_operand:SI 1 "ubicom32_data_register_operand" "=d"))]
6637 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
6638 +  "lsl.4\\t%1, %0, #0")
6639 +
6640 +; Comparison for equality with -1.
6641 +;
6642 +(define_insn "cmpsi_not4_ccwz"
6643 +  [(set (reg CC_REGNO)
6644 +       (compare (match_operand:SI 0 "nonimmediate_operand" "rm")
6645 +                (const_int -1)))]
6646 +  "ubicom32_match_cc_mode(insn, CCWZmode)"
6647 +  "not.4\\t#0, %0")
6648 +
6649 +(define_expand "cmpsi"
6650 +  [(set (reg CC_REGNO)
6651 +       (compare (match_operand:SI 0 "ubicom32_arith_operand" "")
6652 +                (match_operand:SI 1 "ubicom32_compare_operand" "")))]
6653 +  ""
6654 +  "{
6655 +     do
6656 +       {
6657 +        /* Is this a cmpi?  We can't take a memory address as cmpi takes
6658 +            16-bit operands.  */
6659 +        if (register_operand (operands[0], SImode)
6660 +            && CONST_INT_P (operands[1])
6661 +            && satisfies_constraint_N (operands[1]))
6662 +          break;
6663 +
6664 +        /* Must be a sub.4 - if necessary copy an operand into a reg.  */
6665 +        if (! ubicom32_data_register_operand (operands[1], SImode))
6666 +          operands[1] = copy_to_mode_reg (SImode, operands[1]);
6667 +       }
6668 +     while (0);
6669 +
6670 +     ubicom32_compare_op0 = operands[0];
6671 +     ubicom32_compare_op1 = operands[1];
6672 +     DONE;
6673 +   }")
6674 +
6675 +(define_insn "cmpsi_cmpi"
6676 +  [(set (reg CC_REGNO)
6677 +       (compare (match_operand:SI 0 "register_operand" "r")
6678 +                (match_operand 1 "const_int_operand"   "N")))]
6679 +  "(satisfies_constraint_N (operands[1]))"
6680 +  "cmpi\\t%0, %1")
6681 +
6682 +(define_insn "cmpsi_sub4"
6683 +  [(set (reg CC_REGNO)
6684 +       (compare (match_operand:SI 0 "ubicom32_arith_operand"       "rmI")
6685 +                (match_operand:SI 1 "ubicom32_data_register_operand" "d")))]
6686 +  ""
6687 +  "sub.4\\t#0, %0, %1")
6688 +
6689 +; If we're testing for equality we don't have to worry about reversing conditions.
6690 +;
6691 +(define_insn "cmpsi_sub4_ccwz_1"
6692 +  [(set (reg CC_REGNO)
6693 +       (compare (match_operand:SI 0 "nonimmediate_operand"          "rm")
6694 +                (match_operand:SI 1 "ubicom32_data_register_operand" "d")))]
6695 +  "ubicom32_match_cc_mode(insn, CCWZmode)"
6696 +  "sub.4\\t#0, %0, %1")
6697 +
6698 +(define_insn "cmpsi_sub4_ccwz_2"
6699 +  [(set (reg CC_REGNO)
6700 +       (compare (match_operand:SI 0 "ubicom32_data_register_operand" "d")
6701 +                (match_operand:SI 1 "nonimmediate_operand"          "rm")))]
6702 +  "ubicom32_match_cc_mode(insn, CCWZmode)"
6703 +  "sub.4\\t#0, %1, %0")
6704 +
6705 +; When the combiner runs it doesn't have any insight into whether or not an argument
6706 +; to a compare is spilled to the stack and therefore can't swap the comparison in
6707 +; an attempt to use sub.4 more effectively.  We peephole this case here.
6708 +;
6709 +(define_peephole2
6710 +  [(set (match_operand:SI 0 "register_operand" "")
6711 +       (match_operand:SI 1 "ubicom32_arith_operand" ""))
6712 +   (set (match_operand 2 "ubicom32_cc_register_operand" "")
6713 +       (compare (match_operand:SI 3 "ubicom32_data_register_operand" "")
6714 +                (match_dup 0)))
6715 +   (set (pc)
6716 +       (if_then_else (match_operator 4 "comparison_operator"
6717 +                       [(match_dup 2)
6718 +                        (const_int 0)])
6719 +                     (label_ref (match_operand 5 "" ""))
6720 +                     (pc)))]
6721 +  "(peep2_reg_dead_p (2, operands[0])
6722 +    && peep2_regno_dead_p (3, CC_REGNO))"
6723 +  [(set (match_dup 2)
6724 +       (compare (match_dup 1)
6725 +                (match_dup 3)))
6726 +   (set (pc)
6727 +       (if_then_else (match_op_dup 6
6728 +                       [(match_dup 2)
6729 +                        (const_int 0)])
6730 +                     (label_ref (match_dup 5))
6731 +                     (pc)))]
6732 +  "{
6733 +     rtx cc_reg;
6734 +
6735 +     cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO);
6736 +     operands[6] = gen_rtx_fmt_ee (swap_condition (GET_CODE (operands[4])),
6737 +                                  GET_MODE (operands[4]),
6738 +                                  cc_reg,
6739 +                                  const0_rtx);
6740 +   }")
6741 +
6742 +(define_insn_and_split "tstdi_or4"
6743 +  [(set (reg:CCWZ CC_REGNO)
6744 +       (compare:CCWZ (match_operand:DI 0 "nonimmediate_operand" "rm")
6745 +                     (const_int 0)))]
6746 +  ""
6747 +  "#"
6748 +  ""
6749 +  [(parallel
6750 +     [(set (reg:CCWZ CC_REGNO)
6751 +          (compare:CCWZ (match_dup 0)
6752 +                        (const_int 0)))
6753 +      (clobber (match_dup 1))])]
6754 +  "{
6755 +     operands[1] = gen_reg_rtx (SImode);
6756 +   }")
6757 +
6758 +(define_insn "tstdi_or4_d"
6759 +  [(set (reg:CCWZ CC_REGNO)
6760 +       (compare:CCWZ (match_operand:DI 0 "nonimmediate_operand" "rm")
6761 +                     (const_int 0)))
6762 +   (clobber (match_operand:SI 1 "ubicom32_data_register_operand" "=d"))]
6763 +  ""
6764 +  "*
6765 +   {
6766 +     operands[2] = gen_lowpart (SImode, operands[0]);
6767 +     operands[3] = gen_highpart_mode (SImode, DImode, operands[0]);
6768 +
6769 +     if (ubicom32_data_register_operand (operands[0], GET_MODE (operands[0])))
6770 +       return \"or.4\\t#0, %2, %3\";
6771 +
6772 +     return \"move.4\\t%1, %2\;or.4\\t%1, %3, %1\";
6773 +   }"
6774 +  [(set_attr "length" "8")])
6775 +
6776 +(define_expand "cmpdi"
6777 +  [(set (reg CC_REGNO)
6778 +       (compare (match_operand:DI 0 "ubicom32_arith_operand" "")
6779 +                (match_operand:DI 1 "ubicom32_data_register_operand" "")))]
6780 +  ""
6781 +  "{
6782 +     ubicom32_compare_op0 = operands[0];
6783 +     ubicom32_compare_op1 = operands[1];
6784 +     DONE;
6785 +   }")
6786 +
6787 +(define_insn "cmpdi_sub4subc"
6788 +  [(set (reg CC_REGNO)
6789 +       (compare (match_operand:DI 0 "ubicom32_arith_operand"       "rmI")
6790 +                (match_operand:DI 1 "ubicom32_data_register_operand" "d")))]
6791 +  ""
6792 +  "*
6793 +   {
6794 +     operands[2] = gen_lowpart (SImode, operands[0]);
6795 +     operands[3] = gen_lowpart (SImode, operands[1]);
6796 +     operands[4] = gen_highpart_mode (SImode, DImode, operands[0]);
6797 +     operands[5] = gen_highpart_mode (SImode, DImode, operands[1]);
6798 +
6799 +     return \"sub.4\\t#0, %2, %3\;subc\\t#0, %4, %5\";
6800 +   }"
6801 +  [(set_attr "length" "8")])
6802 +
6803 +; When the combiner runs it doesn't have any insight into whether or not an argument
6804 +; to a compare is spilled to the stack and therefore can't swap the comparison in
6805 +; an attempt to use sub.4/subc more effectively.  We peephole this case here.
6806 +;
6807 +(define_peephole2
6808 +  [(set (match_operand:DI 0 "register_operand" "")
6809 +       (match_operand:DI 1 "ubicom32_arith_operand" ""))
6810 +   (set (match_operand 2 "ubicom32_cc_register_operand" "")
6811 +       (compare (match_operand:DI 3 "ubicom32_data_register_operand" "")
6812 +                (match_dup 0)))
6813 +   (set (pc)
6814 +       (if_then_else (match_operator 4 "comparison_operator"
6815 +                       [(match_dup 2)
6816 +                        (const_int 0)])
6817 +                     (label_ref (match_operand 5 "" ""))
6818 +                     (pc)))]
6819 +  "(peep2_reg_dead_p (2, operands[0])
6820 +    && peep2_regno_dead_p (3, CC_REGNO))"
6821 +  [(set (match_dup 2)
6822 +       (compare (match_dup 1)
6823 +                (match_dup 3)))
6824 +   (set (pc)
6825 +       (if_then_else (match_op_dup 6
6826 +                       [(match_dup 2)
6827 +                        (const_int 0)])
6828 +                     (label_ref (match_dup 5))
6829 +                     (pc)))]
6830 +  "{
6831 +     rtx cc_reg;
6832 +
6833 +     cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO);
6834 +     operands[6] = gen_rtx_fmt_ee (swap_condition (GET_CODE (operands[4])),
6835 +                                  GET_MODE (operands[4]),
6836 +                                  cc_reg,
6837 +                                  const0_rtx);
6838 +   }")
6839 +
6840 +(define_insn "btst"
6841 +  [(set (reg:CCWZ CC_REGNO)
6842 +       (compare:CCWZ
6843 +         (zero_extract:SI
6844 +           (match_operand:SI 0 "nonimmediate_operand"   "rm")
6845 +           (const_int 1)
6846 +           (match_operand:SI 1 "ubicom32_arith_operand" "dM"))
6847 +         (const_int 0)))]
6848 +  ""
6849 +  "btst\\t%0, %1")
6850 +
6851 +(define_insn "bfextu_ccwz_null"
6852 +  [(set (reg:CCWZ CC_REGNO)
6853 +       (compare:CCWZ
6854 +         (zero_extract:SI
6855 +           (match_operand:SI 0 "nonimmediate_operand" "rm")
6856 +           (match_operand 1 "const_int_operand"        "M")
6857 +           (const_int 0))
6858 +         (const_int 0)))
6859 +   (clobber (match_scratch:SI 2                               "=d"))]
6860 +  ""
6861 +  "bfextu\\t%2, %0, %1")
6862 +
6863 +(define_expand "addqi3"
6864 +  [(parallel
6865 +     [(set (match_operand:QI 0 "memory_operand" "")
6866 +          (plus:QI (match_operand:QI 1 "nonimmediate_operand" "")
6867 +                   (match_operand:QI 2 "ubicom32_arith_operand" "")))
6868 +      (clobber (reg:CC CC_REGNO))])]
6869 +  "(ubicom32_v4)"
6870 +  "{
6871 +     if (!memory_operand (operands[0], QImode))
6872 +       FAIL;
6873 +
6874 +     /* If we have a non-data reg for operand 1 then prefer that over
6875 +        a CONST_INT in operand 2.  */
6876 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
6877 +        && CONST_INT_P (operands[2]))
6878 +       operands[2] = copy_to_mode_reg (QImode, operands[2]);
6879 +
6880 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
6881 +       operands[2] = copy_to_mode_reg (QImode, operands[2]);
6882 +   }")
6883 +
6884 +(define_insn "addqi3_add1"
6885 +  [(set (match_operand:QI 0 "memory_operand"                  "=m, m")
6886 +       (plus:QI (match_operand:QI 1 "nonimmediate_operand"    "%d,rm")
6887 +                (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d")))
6888 +   (clobber (reg:CC CC_REGNO))]
6889 +  "(ubicom32_v4)"
6890 +  "@
6891 +   add.1\\t%0, %2, %1
6892 +   add.1\\t%0, %1, %2")
6893 +
6894 +(define_insn "addqi3_add1_ccszn_null"
6895 +  [(set (reg CC_REGNO)
6896 +       (compare
6897 +         (neg:QI (match_operand:QI 0 "nonimmediate_operand" "%d,rm"))
6898 +         (match_operand:QI 1 "ubicom32_arith_operand"      "rmI, d")))]
6899 +  "(ubicom32_v4
6900 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
6901 +  "@
6902 +   add.1\\t#0, %1, %0
6903 +   add.1\\t#0, %0, %1")
6904 +
6905 +(define_expand "addhi3"
6906 +  [(parallel
6907 +     [(set (match_operand:HI 0 "memory_operand" "")
6908 +          (plus:HI (match_operand:HI 1 "nonimmediate_operand" "")
6909 +                   (match_operand:HI 2 "ubicom32_arith_operand" "")))
6910 +      (clobber (reg:CC CC_REGNO))])]
6911 +  ""
6912 +  "{
6913 +     if (!memory_operand (operands[0], HImode))
6914 +       FAIL;
6915 +
6916 +     /* If we have a non-data reg for operand 1 then prefer that over
6917 +        a CONST_INT in operand 2.  */
6918 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
6919 +        && CONST_INT_P (operands[2]))
6920 +       operands[2] = copy_to_mode_reg (HImode, operands[2]);
6921 +
6922 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
6923 +       operands[2] = copy_to_mode_reg (HImode, operands[2]);
6924 +   }")
6925 +
6926 +(define_insn "addhi3_add2"
6927 +  [(set (match_operand:HI 0 "memory_operand"                  "=m, m")
6928 +       (plus:HI (match_operand:HI 1 "nonimmediate_operand"    "%d,rm")
6929 +                (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d")))
6930 +   (clobber (reg:CC CC_REGNO))]
6931 +  ""
6932 +  "@
6933 +   add.2\\t%0, %2, %1
6934 +   add.2\\t%0, %1, %2")
6935 +
6936 +(define_insn "addhi3_add2_ccszn_null"
6937 +  [(set (reg CC_REGNO)
6938 +       (compare
6939 +         (neg:HI (match_operand:HI 0 "nonimmediate_operand" "%d,rm"))
6940 +         (match_operand:HI 1 "ubicom32_arith_operand"      "rmI, d")))]
6941 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
6942 +  "@
6943 +   add.2\\t#0, %1, %0
6944 +   add.2\\t#0, %0, %1")
6945 +
6946 +(define_expand "addsi3"
6947 +  [(set (match_operand:SI 0 "nonimmediate_operand" "")
6948 +       (plus:SI (match_operand:SI 1 "nonimmediate_operand" "")
6949 +                (match_operand:SI 2 "ubicom32_move_operand" "")))]
6950 +  ""
6951 +  "{
6952 +     ubicom32_expand_addsi3 (operands);
6953 +     DONE;
6954 +   }")
6955 +
6956 +; We start with an instruction pattern that can do all sorts of interesting
6957 +; things but we split out any uses of lea or pdec instructions because
6958 +; those instructions don't clobber the condition codes.
6959 +;
6960 +(define_insn_and_split "addsi3_1"
6961 +  [(set (match_operand:SI 0 "nonimmediate_operand"        "=rm,rm,rm,rm,rm, rm,rm")
6962 +       (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%a, a, a, a, a,  d,rm")
6963 +                (match_operand:SI 2 "ubicom32_move_operand" "L, K, J, P, d,rmI, d")))
6964 +   (clobber (reg:CC CC_REGNO))]
6965 +  ""
6966 +  "@
6967 +   #
6968 +   #
6969 +   #
6970 +   #
6971 +   #
6972 +   add.4\\t%0, %2, %1
6973 +   add.4\\t%0, %1, %2"
6974 +  "(reload_completed
6975 +    && ubicom32_address_register_operand (operands[1], GET_MODE (operands[1])))"
6976 +  [(set (match_dup 0)
6977 +       (plus:SI (match_dup 1)
6978 +                (match_dup 2)))]
6979 +  ""
6980 +)
6981 +
6982 +(define_insn "addsi3_1_ccwzn"
6983 +  [(set (reg CC_REGNO)
6984 +       (compare
6985 +         (plus:SI (match_operand:SI 1 "nonimmediate_operand"    "%d,rm")
6986 +                  (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d"))
6987 +         (const_int 0)))
6988 +   (set (match_operand:SI 0 "nonimmediate_operand"             "=rm,rm")
6989 +       (plus:SI (match_dup 1)
6990 +                (match_dup 2)))]
6991 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
6992 +  "@
6993 +   add.4\\t%0, %2, %1
6994 +   add.4\\t%0, %1, %2")
6995 +
6996 +(define_insn "addsi3_1_ccwzn_null"
6997 +  [(set (reg CC_REGNO)
6998 +       (compare
6999 +         (neg:SI (match_operand:SI 0 "nonimmediate_operand" "%d,rm"))
7000 +         (match_operand:SI 1 "ubicom32_arith_operand"      "rmI, d")))]
7001 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
7002 +  "@
7003 +   add.4\\t#0, %1, %0
7004 +   add.4\\t#0, %0, %1")
7005 +
7006 +(define_insn_and_split "addsi3_2"
7007 +  [(set (match_operand:SI 0 "nonimmediate_operand"                     "=rm,rm,rm,rm,rm,rm")
7008 +       (plus:SI (match_operand:SI 1 "ubicom32_address_register_operand" "%a, a, a, a, a, a")
7009 +                (match_operand:SI 2 "ubicom32_move_operand"              "L, K, J, P, d, n")))]
7010 +  ""
7011 +  "@
7012 +   lea.4\\t%0, %E2(%1)
7013 +   lea.2\\t%0, %E2(%1)
7014 +   lea.1\\t%0, %E2(%1)
7015 +   pdec\\t%0, %n2(%1)
7016 +   lea.1\\t%0, (%1,%2)
7017 +   #"
7018 +  "(reload_completed
7019 +    && ! satisfies_constraint_L (operands[2])
7020 +    && ! satisfies_constraint_K (operands[2])
7021 +    && ! satisfies_constraint_J (operands[2])
7022 +    && ! satisfies_constraint_P (operands[2])
7023 +    && ! ubicom32_data_register_operand (operands[2], GET_MODE (operands[2])))"
7024 +  [(set (reg:SI AUX_DATA_REGNO)
7025 +       (match_dup 2))
7026 +   (set (match_dup 0)
7027 +       (plus:SI (match_dup 1)
7028 +                (reg:SI AUX_DATA_REGNO)))]
7029 +  ""
7030 +)
7031 +
7032 +(define_insn "lea_2"
7033 +  [(set (match_operand:SI 0 "nonimmediate_operand"                          "=rm")
7034 +       (plus:SI (mult:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d")
7035 +                         (const_int 2))
7036 +                (match_operand:SI 2 "ubicom32_address_register_operand"       "a")))]
7037 +  ""
7038 +  "lea.2\\t%0, (%2,%1)")
7039 +
7040 +(define_insn "lea_4"
7041 +  [(set (match_operand:SI 0 "nonimmediate_operand"                          "=rm")
7042 +       (plus:SI (mult:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d")
7043 +                         (const_int 4))
7044 +                (match_operand:SI 2 "ubicom32_address_register_operand"       "a")))]
7045 +  ""
7046 +  "lea.4\\t%0, (%2,%1)")
7047 +
7048 +(define_expand "adddi3"
7049 +  [(parallel
7050 +     [(set (match_operand:DI 0 "nonimmediate_operand" "")
7051 +          (plus:DI (match_operand:DI 1 "nonimmediate_operand" "")
7052 +                   (match_operand:DI 2 "ubicom32_arith_operand" "")))
7053 +      (clobber (reg:CC CC_REGNO))])]
7054 +  ""
7055 +  "{
7056 +     /* If we have a non-data reg for operand 1 then prefer that over
7057 +        a CONST_INT in operand 2.  */
7058 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
7059 +        && CONST_INT_P (operands[2]))
7060 +       operands[2] = copy_to_mode_reg (DImode, operands[2]);
7061 +
7062 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
7063 +       operands[2] = copy_to_mode_reg (DImode, operands[2]);
7064 +   }")
7065 +
7066 +; We construct a 64-bit add from 32-bit operations.  Note that we use the
7067 +; & constraint to prevent overlapping registers being allocated.  We do
7068 +; allow identical registers though as that won't break anything.
7069 +;
7070 +(define_insn "adddi3_add4addc"
7071 +  [(set (match_operand:DI 0 "nonimmediate_operand"           "=&r,&r,rm,  d,  m, m")
7072 +       (plus:DI (match_operand:DI 1 "nonimmediate_operand"    "%d,rm, 0,  0,  d,rm")
7073 +                (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d, d,rmI,rmI, d")))
7074 +   (clobber (reg:CC CC_REGNO))]
7075 +  ""
7076 +  "*
7077 +   {
7078 +     operands[3] = gen_lowpart (SImode, operands[0]);
7079 +     operands[4] = gen_lowpart (SImode, operands[1]);
7080 +     operands[5] = gen_lowpart (SImode, operands[2]);
7081 +     operands[6] = gen_highpart (SImode, operands[0]);
7082 +     operands[7] = gen_highpart (SImode, operands[1]);
7083 +     operands[8] = gen_highpart_mode (SImode, DImode, operands[2]);
7084 +
7085 +     if (ubicom32_data_register_operand (operands[2], GET_MODE (operands[2])))
7086 +       return \"add.4\\t%3, %4, %5\;addc\\t%6, %7, %8\";
7087 +
7088 +     return \"add.4\\t%3, %5, %4\;addc\\t%6, %8, %7\";
7089 +   }"
7090 +  [(set_attr "length" "8")])
7091 +
7092 +(define_insn "adddi3_ccwz"
7093 +  [(set (reg CC_REGNO)
7094 +       (compare
7095 +         (plus:DI (match_operand:DI 1 "nonimmediate_operand"    "%d,rm, 0,  0,  d,rm")
7096 +                  (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d, d,rmI,rmI, d"))
7097 +         (const_int 0)))
7098 +   (set (match_operand:DI 0 "nonimmediate_operand"             "=&r,&r,rm,  d,  m, m")
7099 +       (plus:DI (match_dup 1)
7100 +                (match_dup 2)))]
7101 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
7102 +  "*
7103 +   {
7104 +     operands[3] = gen_lowpart (SImode, operands[0]);
7105 +     operands[6] = gen_highpart (SImode, operands[0]);
7106 +
7107 +     if (ubicom32_data_register_operand (operands[1], GET_MODE (operands[1])))
7108 +       {
7109 +        operands[4] = gen_lowpart (SImode, operands[1]);
7110 +        operands[5] = gen_lowpart (SImode, operands[2]);
7111 +        operands[7] = gen_highpart (SImode, operands[1]);
7112 +        operands[8] = gen_highpart_mode (SImode, DImode, operands[2]);
7113 +       }
7114 +     else
7115 +       {
7116 +        operands[4] = gen_lowpart (SImode, operands[2]);
7117 +        operands[5] = gen_lowpart (SImode, operands[1]);
7118 +        operands[7] = gen_highpart (SImode, operands[2]);
7119 +        operands[8] = gen_highpart (SImode, operands[1]);
7120 +       }
7121 +
7122 +     return \"add.4\\t%3, %5, %4\;addc\\t%6, %8, %7\";
7123 +   }"
7124 +  [(set_attr "length" "8")])
7125 +
7126 +(define_insn "adddi3_ccwz_null"
7127 +  [(set (reg CC_REGNO)
7128 +       (compare
7129 +         (neg:DI (match_operand:DI 0 "nonimmediate_operand" "%d,rm"))
7130 +         (match_operand:DI 1 "ubicom32_arith_operand"      "rmI, d")))]
7131 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
7132 +  "*
7133 +   {
7134 +     if (ubicom32_data_register_operand (operands[0], GET_MODE (operands[0])))
7135 +       {
7136 +        operands[2] = gen_lowpart (SImode, operands[0]);
7137 +        operands[3] = gen_lowpart (SImode, operands[1]);
7138 +        operands[4] = gen_highpart (SImode, operands[0]);
7139 +        operands[5] = gen_highpart_mode (SImode, DImode, operands[1]);
7140 +       }
7141 +     else
7142 +       {
7143 +        operands[2] = gen_lowpart (SImode, operands[1]);
7144 +        operands[3] = gen_lowpart (SImode, operands[0]);
7145 +        operands[4] = gen_highpart (SImode, operands[1]);
7146 +        operands[5] = gen_highpart (SImode, operands[0]);
7147 +       }
7148 +
7149 +     return \"add.4\\t#0, %3, %2\;addc\\t#0, %5, %4\";
7150 +   }"
7151 +  [(set_attr "length" "8")])
7152 +
7153 +(define_expand "subqi3"
7154 +  [(parallel
7155 +     [(set (match_operand:QI 0 "memory_operand" "")
7156 +          (minus:QI (match_operand:QI 1 "ubicom32_arith_operand" "")
7157 +                    (match_operand:QI 2 "ubicom32_data_register_operand" "")))
7158 +      (clobber (reg:CC CC_REGNO))])]
7159 +  "(ubicom32_v4)"
7160 +  "{
7161 +     if (!memory_operand (operands[0], QImode))
7162 +       FAIL;
7163 +   }")
7164 +
7165 +(define_insn "subqi3_sub1"
7166 +  [(set (match_operand:QI 0 "memory_operand"                         "=m")
7167 +       (minus:QI (match_operand:QI 1 "ubicom32_arith_operand"       "rmI")
7168 +                 (match_operand:QI 2 "ubicom32_data_register_operand" "d")))
7169 +   (clobber (reg:CC CC_REGNO))]
7170 +  "(ubicom32_v4)"
7171 +  "sub.1\\t%0, %1, %2")
7172 +
7173 +(define_expand "subhi3"
7174 +  [(parallel
7175 +     [(set (match_operand:HI 0 "memory_operand" "")
7176 +          (minus:HI (match_operand:HI 1 "ubicom32_arith_operand" "")
7177 +                    (match_operand:HI 2 "ubicom32_data_register_operand" "")))
7178 +      (clobber (reg:CC CC_REGNO))])]
7179 +  "(ubicom32_v4)"
7180 +  "{
7181 +     if (!memory_operand (operands[0], HImode))
7182 +       FAIL;
7183 +   }")
7184 +
7185 +(define_insn "subhi3_sub2"
7186 +  [(set (match_operand:HI 0 "memory_operand"                         "=m")
7187 +       (minus:HI (match_operand:HI 1 "ubicom32_arith_operand"       "rmI")
7188 +                 (match_operand:HI 2 "ubicom32_data_register_operand" "d")))
7189 +   (clobber (reg:CC CC_REGNO))]
7190 +  ""
7191 +  "sub.2\\t%0, %1, %2")
7192 +
7193 +(define_insn "subsi3"
7194 +  [(set (match_operand:SI 0 "nonimmediate_operand"                  "=rm")
7195 +       (minus:SI (match_operand:SI 1 "ubicom32_arith_operand"       "rmI")
7196 +                 (match_operand:SI 2 "ubicom32_data_register_operand" "d")))
7197 +   (clobber (reg:CC CC_REGNO))]
7198 +  ""
7199 +  "sub.4\\t%0, %1, %2")
7200 +
7201 +(define_insn "subsi3_ccwz"
7202 +  [(set (reg CC_REGNO)
7203 +       (compare
7204 +         (minus:SI (match_operand:SI 1 "ubicom32_arith_operand"       "rmI")
7205 +                   (match_operand:SI 2 "ubicom32_data_register_operand" "d"))
7206 +         (const_int 0)))
7207 +   (set (match_operand:SI 0 "nonimmediate_operand"                    "=rm")
7208 +       (minus:SI (match_dup 1)
7209 +                 (match_dup 2)))]
7210 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
7211 +  "sub.4\\t%0, %1, %2")
7212 +
7213 +; We construct a 64-bit add from 32-bit operations.  Note that we use the
7214 +; & constraint to prevent overlapping registers being allocated.  We do
7215 +; allow identical registers though as that won't break anything.
7216 +;
7217 +(define_insn "subdi3"
7218 +  [(set (match_operand:DI 0 "nonimmediate_operand"                  "=&r,r,  d,  m")
7219 +       (minus:DI (match_operand:DI 1 "ubicom32_arith_operand"       "rmI,0,rmI,rmI")
7220 +                 (match_operand:DI 2 "ubicom32_data_register_operand" "d,d,  0,  d")))
7221 +   (clobber (reg:CC CC_REGNO))]
7222 +  ""
7223 +  "*
7224 +   {
7225 +     operands[3] = gen_lowpart (SImode, operands[0]);
7226 +     operands[4] = gen_lowpart (SImode, operands[1]);
7227 +     operands[5] = gen_lowpart (SImode, operands[2]);
7228 +     operands[6] = gen_highpart (SImode, operands[0]);
7229 +     operands[7] = gen_highpart_mode (SImode, DImode, operands[1]);
7230 +     operands[8] = gen_highpart (SImode, operands[2]);
7231 +
7232 +     return \"sub.4\\t%3, %4, %5\;subc\\t%6, %7, %8\";
7233 +   }"
7234 +  [(set_attr "length" "8")])
7235 +
7236 +(define_insn "subdi3_ccwz"
7237 +  [(set (reg CC_REGNO)
7238 +       (compare
7239 +         (minus:DI (match_operand:DI 1 "ubicom32_arith_operand"       "rmI,rmI")
7240 +                   (match_operand:DI 2 "ubicom32_data_register_operand" "d,  d"))
7241 +         (const_int 0)))
7242 +   (set (match_operand:DI 0 "nonimmediate_operand"                    "=&r,  m")
7243 +       (minus:DI (match_dup 1)
7244 +                 (match_dup 2)))]
7245 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
7246 +  "*
7247 +   {
7248 +     operands[3] = gen_lowpart (SImode, operands[0]);
7249 +     operands[4] = gen_lowpart (SImode, operands[1]);
7250 +     operands[5] = gen_lowpart (SImode, operands[2]);
7251 +     operands[6] = gen_highpart (SImode, operands[0]);
7252 +     operands[7] = gen_highpart_mode (SImode, DImode, operands[1]);
7253 +     operands[8] = gen_highpart (SImode, operands[2]);
7254 +
7255 +     return \"sub.4\\t%3, %4, %5\;subc\\t%6, %7, %8\";
7256 +   }"
7257 +  [(set_attr "length" "8")])
7258 +
7259 +;(define_insn "negqi2"
7260 +;  [(set (match_operand:QI 0 "nonimmediate_operand"               "=rm")
7261 +;      (neg:QI (match_operand:QI 1 "ubicom32_data_register_operand" "d")))
7262 +;   (clobber (reg:CC CC_REGNO))]
7263 +;  "(ubicom32_v4)"
7264 +;  "sub.1\\t%0, #0, %1")
7265 +
7266 +;(define_insn "neghi2"
7267 +;  [(set (match_operand:HI 0 "nonimmediate_operand"               "=rm")
7268 +;      (neg:HI (match_operand:HI 1 "ubicom32_data_register_operand" "d")))
7269 +;   (clobber (reg:CC CC_REGNO))]
7270 +;  ""
7271 +;  "sub.2\\t%0, #0, %1")
7272 +
7273 +(define_insn "negsi2"
7274 +  [(set (match_operand:SI 0 "nonimmediate_operand"                "=rm")
7275 +       (neg:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d")))
7276 +   (clobber (reg:CC CC_REGNO))]
7277 +  ""
7278 +  "sub.4\\t%0, #0, %1")
7279 +
7280 +(define_insn_and_split "negdi2"
7281 +  [(set (match_operand:DI 0 "nonimmediate_operand"               "=&rm")
7282 +       (neg:DI (match_operand:DI 1 "ubicom32_data_register_operand" "d")))
7283 +   (clobber (reg:CC CC_REGNO))]
7284 +  ""
7285 +  "#"
7286 +  "reload_completed"
7287 +  [(parallel [(set (match_dup 0)
7288 +                  (minus:DI (const_int 0)
7289 +                            (match_dup 1)))
7290 +             (clobber (reg:CC CC_REGNO))])]
7291 +  ""
7292 +  [(set_attr "length" "8")])
7293 +
7294 +(define_insn "umulhisi3"
7295 +  [(set (match_operand:SI 0 "ubicom32_acc_lo_register_operand"      "=l, l")
7296 +       (mult:SI
7297 +         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "%d,rm"))
7298 +         (zero_extend:SI (match_operand:HI 2 "nonimmediate_operand" "rm, d"))))
7299 +   (clobber (reg:HI ACC0_HI_REGNO))
7300 +   (clobber (reg:HI ACC1_HI_REGNO))]
7301 +  ""
7302 +  "@
7303 +   mulu\\t%A0, %2, %1
7304 +   mulu\\t%A0, %1, %2"
7305 +  [(set_attr "type" "mul,mul")])
7306 +
7307 +(define_insn "mulhisi3"
7308 +  [(set (match_operand:SI 0 "ubicom32_acc_lo_register_operand"      "=l, l")
7309 +       (mult:SI
7310 +         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "%d,rm"))
7311 +         (sign_extend:SI (match_operand:HI 2 "nonimmediate_operand" "rm, d"))))
7312 +   (clobber (reg:HI ACC0_HI_REGNO))
7313 +   (clobber (reg:HI ACC1_HI_REGNO))]
7314 +  ""
7315 +  "@
7316 +   muls\\t%A0, %2, %1
7317 +   muls\\t%A0, %1, %2"
7318 +  [(set_attr "type" "mul,mul")])
7319 +
7320 +(define_expand "mulsi3"
7321 +  [(set (match_operand:SI 0 "ubicom32_acc_hi_register_operand" "")
7322 +       (mult:SI (match_operand:SI 1 "ubicom32_arith_operand" "")
7323 +                (match_operand:SI 2 "ubicom32_arith_operand" "")))]
7324 +  ""
7325 +  "{
7326 +     if (ubicom32_emit_mult_sequence (operands))
7327 +       DONE;
7328 +   }")
7329 +
7330 +(define_insn "umulsidi3"
7331 +  [(set (match_operand:DI 0 "ubicom32_acc_hi_register_operand"      "=h, h")
7332 +       (mult:DI
7333 +         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "%d,rm"))
7334 +         (zero_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm, d"))))]
7335 +  "(ubicom32_v4)"
7336 +  "@
7337 +   mulu.4\\t%A0, %2, %1
7338 +   mulu.4\\t%A0, %1, %2"
7339 +  [(set_attr "type" "mul,mul")])
7340 +
7341 +(define_peephole2
7342 +  [(set (match_operand:SI 0 "register_operand" "")
7343 +       (match_operand:SI 1 "nonimmediate_operand" ""))
7344 +   (set (match_operand:DI 2 "ubicom32_acc_hi_register_operand" "")
7345 +       (mult:DI
7346 +         (zero_extend:DI (match_dup 0))
7347 +         (zero_extend:DI (match_operand:SI 3 "ubicom32_data_register_operand" ""))))]
7348 +  "(peep2_reg_dead_p (2, operands[0])
7349 +    || REGNO (operands[0]) == REGNO (operands[2])
7350 +    || REGNO (operands[0]) == REGNO (operands[2]) + 1)
7351 +   && ! rtx_equal_p (operands[0], operands[3])"
7352 +  [(set (match_dup 2)
7353 +       (mult:DI
7354 +         (zero_extend:DI (match_dup 1))
7355 +         (zero_extend:DI (match_dup 3))))]
7356 +  "")
7357 +
7358 +(define_peephole2
7359 +  [(set (match_operand:SI 0 "register_operand" "")
7360 +       (match_operand:SI 1 "nonimmediate_operand" ""))
7361 +   (set (match_operand:DI 2 "ubicom32_acc_hi_register_operand" "")
7362 +       (mult:DI
7363 +         (zero_extend:DI (match_operand:SI 3 "ubicom32_data_register_operand" ""))
7364 +         (zero_extend:DI (match_dup 0))))]
7365 +  "(peep2_reg_dead_p (2, operands[0])
7366 +    || REGNO (operands[0]) == REGNO (operands[2])
7367 +    || REGNO (operands[0]) == REGNO (operands[2]) + 1)
7368 +   && ! rtx_equal_p (operands[0], operands[3])"
7369 +  [(set (match_dup 2)
7370 +       (mult:DI
7371 +         (zero_extend:DI (match_dup 1))
7372 +         (zero_extend:DI (match_dup 3))))]
7373 +  "")
7374 +
7375 +(define_insn "umulsidi3_const"
7376 +  [(set (match_operand:DI 0 "ubicom32_acc_hi_register_operand"                "=h")
7377 +       (mult:DI
7378 +         (zero_extend:DI (match_operand:SI 1 "ubicom32_data_register_operand" "%d"))
7379 +         (match_operand 2 "const_int_operand"                                  "I")))]
7380 +  "(ubicom32_v4 && satisfies_constraint_I (operands[2]))"
7381 +  "mulu.4\\t%A0, %2, %1"
7382 +  [(set_attr "type" "mul")])
7383 +
7384 +(define_insn "mulsidi3"
7385 +  [(set (match_operand:DI 0 "ubicom32_acc_hi_register_operand"      "=h, h")
7386 +       (mult:DI
7387 +         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "%d,rm"))
7388 +         (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm, d"))))]
7389 +  "(ubicom32_v4)"
7390 +  "@
7391 +   muls.4\\t%A0, %2, %1
7392 +   muls.4\\t%A0, %1, %2"
7393 +  [(set_attr "type" "mul,mul")])
7394 +
7395 +(define_peephole2
7396 +  [(set (match_operand:SI 0 "register_operand" "")
7397 +       (match_operand:SI 1 "nonimmediate_operand" ""))
7398 +   (set (match_operand:DI 2 "ubicom32_acc_hi_register_operand" "")
7399 +       (mult:DI
7400 +         (sign_extend:DI (match_dup 0))
7401 +         (sign_extend:DI (match_operand:SI 3 "ubicom32_data_register_operand" ""))))]
7402 +  "(peep2_reg_dead_p (2, operands[0])
7403 +    || REGNO (operands[0]) == REGNO (operands[2])
7404 +    || REGNO (operands[0]) == REGNO (operands[2]) + 1)
7405 +   && ! rtx_equal_p (operands[0], operands[3])"
7406 +  [(set (match_dup 2)
7407 +       (mult:DI
7408 +         (sign_extend:DI (match_dup 1))
7409 +         (sign_extend:DI (match_dup 3))))]
7410 +  "")
7411 +
7412 +(define_peephole2
7413 +  [(set (match_operand:SI 0 "register_operand" "")
7414 +       (match_operand:SI 1 "nonimmediate_operand" ""))
7415 +   (set (match_operand:DI 2 "ubicom32_acc_hi_register_operand" "")
7416 +       (mult:DI
7417 +         (sign_extend:DI (match_operand:SI 3 "ubicom32_data_register_operand" ""))
7418 +         (sign_extend:DI (match_dup 0))))]
7419 +  "(peep2_reg_dead_p (2, operands[0])
7420 +    || REGNO (operands[0]) == REGNO (operands[2])
7421 +    || REGNO (operands[0]) == REGNO (operands[2]) + 1)
7422 +   && ! rtx_equal_p (operands[0], operands[3])"
7423 +  [(set (match_dup 2)
7424 +       (mult:DI
7425 +         (sign_extend:DI (match_dup 1))
7426 +         (sign_extend:DI (match_dup 3))))]
7427 +  "")
7428 +
7429 +(define_insn "mulsidi3_const"
7430 +  [(set (match_operand:DI 0 "ubicom32_acc_hi_register_operand"                "=h")
7431 +       (mult:DI
7432 +         (sign_extend:DI (match_operand:SI 1 "ubicom32_data_register_operand" "%d"))
7433 +         (match_operand 2 "const_int_operand"                                  "I")))]
7434 +  "(ubicom32_v4 && satisfies_constraint_I (operands[2]))"
7435 +  "muls.4\\t%A0, %2, %1"
7436 +  [(set_attr "type" "mul")])
7437 +
7438 +(define_expand "andqi3"
7439 +  [(parallel
7440 +     [(set (match_operand:QI 0 "memory_operand" "")
7441 +          (and:QI (match_operand:QI 1 "nonimmediate_operand" "")
7442 +                  (match_operand:QI 2 "ubicom32_arith_operand" "")))
7443 +      (clobber (reg:CC CC_REGNO))])]
7444 +  "(ubicom32_v4)"
7445 +  "{
7446 +     if (!memory_operand (operands[0], QImode))
7447 +       FAIL;
7448 +
7449 +     /* If we have a non-data reg for operand 1 then prefer that over
7450 +        a CONST_INT in operand 2.  */
7451 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
7452 +        && CONST_INT_P (operands[2]))
7453 +       operands[2] = copy_to_mode_reg (QImode, operands[2]);
7454 +
7455 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
7456 +       operands[2] = copy_to_mode_reg (QImode, operands[2]);
7457 +   }")
7458 +
7459 +(define_insn "andqi3_and1"
7460 +  [(set (match_operand:QI 0 "memory_operand"                 "=m, m")
7461 +       (and:QI (match_operand:QI 1 "nonimmediate_operand"    "%d,rm")
7462 +               (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d")))
7463 +   (clobber (reg:CC CC_REGNO))]
7464 +  "(ubicom32_v4)"
7465 +  "@
7466 +   and.1\\t%0, %2, %1
7467 +   and.1\\t%0, %1, %2")
7468 +
7469 +(define_insn "andqi3_and1_ccszn"
7470 +  [(set (reg CC_REGNO)
7471 +       (compare
7472 +         (and:QI (match_operand:QI 1 "nonimmediate_operand"    "%d,rm")
7473 +                 (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d"))
7474 +         (const_int 0)))
7475 +   (set (match_operand:QI 0 "memory_operand"                   "=m, m")
7476 +       (and:QI (match_dup 1)
7477 +               (match_dup 2)))]
7478 +  "(ubicom32_v4
7479 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
7480 +  "@
7481 +   and.1\\t%0, %2, %1
7482 +   and.1\\t%0, %1, %2")
7483 +
7484 +(define_insn "andqi3_and1_ccszn_null"
7485 +  [(set (reg CC_REGNO)
7486 +       (compare
7487 +         (and:QI (match_operand:QI 0 "nonimmediate_operand"    "%d,rm")
7488 +                 (match_operand:QI 1 "ubicom32_arith_operand" "rmI, d"))
7489 +         (const_int 0)))]
7490 +  "(ubicom32_v4
7491 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
7492 +  "@
7493 +   and.1\\t#0, %1, %0
7494 +   and.1\\t#0, %0, %1")
7495 +
7496 +(define_insn "and1_ccszn_null_1"
7497 +  [(set (reg CC_REGNO)
7498 +       (compare
7499 +         (subreg:QI
7500 +           (and:SI (match_operand:SI 0 "ubicom32_data_register_operand" "%d")
7501 +                   (match_operand:SI 1 "ubicom32_arith_operand"         "rI"))
7502 +           3)
7503 +         (const_int 0)))]
7504 +  "(ubicom32_v4
7505 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
7506 +  "and.1\\t#0, %1, %0")
7507 +
7508 +(define_insn "and1_ccszn_null_2"
7509 +  [(set (reg CC_REGNO)
7510 +       (compare
7511 +         (subreg:QI
7512 +           (and:SI (match_operand:SI 0 "ubicom32_data_register_operand" "d")
7513 +                   (subreg:SI
7514 +                     (match_operand:QI 1 "memory_operand"               "m")
7515 +                     0))
7516 +           3)
7517 +         (const_int 0)))]
7518 +  "(ubicom32_v4
7519 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
7520 +  "and.1\\t#0, %1, %0")
7521 +
7522 +(define_insn "and1_ccszn_null_3"
7523 +  [(set (reg CC_REGNO)
7524 +       (compare
7525 +         (subreg:QI
7526 +           (and:SI (subreg:SI
7527 +                     (match_operand:QI 0 "memory_operand"               "m")
7528 +                     0)
7529 +                   (match_operand:SI 1 "ubicom32_data_register_operand" "d"))
7530 +           3)
7531 +         (const_int 0)))]
7532 +  "(ubicom32_v4
7533 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
7534 +  "and.1\\t#0, %0, %1")
7535 +
7536 +(define_expand "andhi3"
7537 +  [(parallel
7538 +     [(set (match_operand:HI 0 "memory_operand" "")
7539 +          (and:HI (match_operand:HI 1 "nonimmediate_operand" "")
7540 +                  (match_operand:HI 2 "ubicom32_arith_operand" "")))
7541 +      (clobber (reg:CC CC_REGNO))])]
7542 +  ""
7543 +  "{
7544 +     if (!memory_operand (operands[0], HImode))
7545 +       FAIL;
7546 +
7547 +     /* If we have a non-data reg for operand 1 then prefer that over
7548 +        a CONST_INT in operand 2.  */
7549 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
7550 +        && CONST_INT_P (operands[2]))
7551 +       operands[2] = copy_to_mode_reg (HImode, operands[2]);
7552 +
7553 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
7554 +       operands[2] = copy_to_mode_reg (HImode, operands[2]);
7555 +   }")
7556 +
7557 +(define_insn "andhi3_and2"
7558 +  [(set (match_operand:HI 0 "memory_operand"                 "=m, m")
7559 +       (and:HI (match_operand:HI 1 "nonimmediate_operand"    "%d,rm")
7560 +               (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d")))
7561 +   (clobber (reg:CC CC_REGNO))]
7562 +  ""
7563 +  "@
7564 +   and.2\\t%0, %2, %1
7565 +   and.2\\t%0, %1, %2")
7566 +
7567 +(define_insn "andhi3_and2_ccszn"
7568 +  [(set (reg CC_REGNO)
7569 +       (compare
7570 +         (and:HI (match_operand:HI 1 "nonimmediate_operand"    "%d,rm")
7571 +                 (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d"))
7572 +         (const_int 0)))
7573 +   (set (match_operand:HI 0 "memory_operand"                   "=m, m")
7574 +       (and:HI (match_dup 1)
7575 +               (match_dup 2)))]
7576 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
7577 +  "@
7578 +   and.2\\t%0, %2, %1
7579 +   and.2\\t%0, %1, %2")
7580 +
7581 +(define_insn "andhi3_and2_ccszn_null"
7582 +  [(set (reg CC_REGNO)
7583 +       (compare
7584 +         (and:HI (match_operand:HI 0 "nonimmediate_operand"    "%d,rm")
7585 +                 (match_operand:HI 1 "ubicom32_arith_operand" "rmI, d"))
7586 +         (const_int 0)))]
7587 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
7588 +  "@
7589 +   and.2\\t#0, %1, %0
7590 +   and.2\\t#0, %0, %1")
7591 +
7592 +(define_insn "and2_ccszn_null_1"
7593 +  [(set (reg CC_REGNO)
7594 +       (compare
7595 +         (subreg:HI
7596 +           (and:SI (match_operand:SI 0 "ubicom32_data_register_operand" "%d")
7597 +                   (match_operand:SI 1 "ubicom32_arith_operand"         "rI"))
7598 +           2)
7599 +         (const_int 0)))]
7600 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
7601 +  "and.2\\t#0, %1, %0")
7602 +
7603 +(define_insn "and2_ccszn_null_2"
7604 +  [(set (reg CC_REGNO)
7605 +       (compare
7606 +         (subreg:HI
7607 +           (and:SI (match_operand:SI 0 "ubicom32_data_register_operand" "d")
7608 +                   (subreg:SI
7609 +                     (match_operand:HI 1 "memory_operand"               "m")
7610 +                     0))
7611 +           2)
7612 +         (const_int 0)))]
7613 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
7614 +  "and.2\\t#0, %1, %0")
7615 +
7616 +(define_insn "and2_ccszn_null_3"
7617 +  [(set (reg CC_REGNO)
7618 +       (compare
7619 +         (subreg:HI
7620 +           (and:SI (subreg:SI
7621 +                     (match_operand:HI 0 "memory_operand"               "m")
7622 +                     0)
7623 +                   (match_operand:SI 1 "ubicom32_data_register_operand" "d"))
7624 +           2)
7625 +         (const_int 0)))]
7626 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
7627 +  "and.2\\t#0, %0, %1")
7628 +
7629 +(define_expand "andsi3"
7630 +  [(parallel
7631 +     [(set (match_operand:SI 0 "nonimmediate_operand" "")
7632 +          (and:SI (match_operand:SI 1 "nonimmediate_operand" "")
7633 +                  (match_operand:SI 2 "ubicom32_and_or_si3_operand" "")))
7634 +      (clobber (reg:CC CC_REGNO))])]
7635 +  ""
7636 +  "{
7637 +     do
7638 +       {
7639 +        /* Is this a bfextu?  */
7640 +        if (ubicom32_data_register_operand (operands[0], SImode)
7641 +            && CONST_INT_P (operands[2])
7642 +            && exact_log2 (INTVAL (operands[2]) + 1) != -1)
7643 +          break;
7644 +
7645 +        /* Is this a bclr?  */
7646 +        if (CONST_INT_P (operands[2])
7647 +            && exact_log2 (~INTVAL (operands[2])) != -1)
7648 +          break;
7649 +
7650 +        /* Must be an and.4  */
7651 +        if (!ubicom32_data_register_operand (operands[1], SImode))
7652 +          operands[1] = copy_to_mode_reg (SImode, operands[1]);
7653 +
7654 +        if (!ubicom32_arith_operand (operands[2], SImode))
7655 +          operands[2] = copy_to_mode_reg (SImode, operands[2]);
7656 +       }
7657 +     while (0);
7658 +   }")
7659 +
7660 +(define_insn "andsi3_bfextu"
7661 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d")
7662 +       (and:SI (match_operand:SI 1 "nonimmediate_operand"  "%rm")
7663 +               (match_operand:SI 2 "const_int_operand"       "O")))
7664 +   (clobber (reg:CC CC_REGNO))]
7665 +  "(satisfies_constraint_O (operands[2]))"
7666 +  "*
7667 +   {
7668 +     operands[3] = GEN_INT (exact_log2 (INTVAL (operands[2]) + 1));
7669 +
7670 +     return \"bfextu\\t%0, %1, %3\";
7671 +   }")
7672 +
7673 +(define_insn "andsi3_bfextu_ccwz"
7674 +  [(set (reg CC_REGNO)
7675 +       (compare
7676 +         (and:SI (match_operand:SI 1 "nonimmediate_operand" "%rm")
7677 +                 (match_operand:SI 2 "const_int_operand"      "O"))
7678 +         (const_int 0)))
7679 +   (set (match_operand:SI 0 "ubicom32_data_register_operand"  "=d")
7680 +       (and:SI (match_dup 1)
7681 +               (match_dup 2)))]
7682 +  "(satisfies_constraint_O (operands[2])
7683 +    && ubicom32_match_cc_mode(insn, CCWZmode))"
7684 +  "*
7685 +   {
7686 +     operands[3] = GEN_INT (exact_log2 (INTVAL (operands[2]) + 1));
7687 +
7688 +     return \"bfextu\\t%0, %1, %3\";
7689 +   }")
7690 +
7691 +(define_insn "andsi3_bfextu_ccwz_null"
7692 +  [(set (reg CC_REGNO)
7693 +       (compare
7694 +         (and:SI (match_operand:SI 0 "nonimmediate_operand" "%rm")
7695 +                 (match_operand:SI 1 "const_int_operand"      "O"))
7696 +         (const_int 0)))
7697 +   (clobber (match_scratch:SI 2                                      "=d"))]
7698 +  "(satisfies_constraint_O (operands[1])
7699 +    && ubicom32_match_cc_mode(insn, CCWZmode))"
7700 +  "*
7701 +   {
7702 +     operands[3] = GEN_INT (exact_log2 (INTVAL (operands[1]) + 1));
7703 +
7704 +     return \"bfextu\\t%2, %0, %3\";
7705 +   }")
7706 +
7707 +(define_insn "andsi3_bclr"
7708 +  [(set (match_operand:SI 0 "nonimmediate_operand"           "=rm")
7709 +       (and:SI (match_operand:SI 1 "ubicom32_arith_operand" "%rmI")
7710 +               (match_operand:SI 2 "const_int_operand"         "n")))
7711 +   (clobber (reg:CC CC_REGNO))]
7712 +  "(exact_log2 (~INTVAL (operands[2])) != -1)"
7713 +  "bclr\\t%0, %1, #%D2")
7714 +
7715 +(define_insn "andsi3_and4"
7716 +  [(set (match_operand:SI 0 "nonimmediate_operand"          "=rm,rm")
7717 +       (and:SI (match_operand:SI 1 "nonimmediate_operand"    "%d,rm")
7718 +               (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d")))
7719 +   (clobber (reg:CC CC_REGNO))]
7720 +  ""
7721 +  "@
7722 +   and.4\\t%0, %2, %1
7723 +   and.4\\t%0, %1, %2")
7724 +
7725 +(define_insn "andsi3_and4_ccwzn"
7726 +  [(set (reg CC_REGNO)
7727 +       (compare
7728 +         (and:SI (match_operand:SI 1 "nonimmediate_operand"    "%d,rm")
7729 +                 (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d"))
7730 +         (const_int 0)))
7731 +   (set (match_operand:SI 0 "nonimmediate_operand"            "=rm,rm")
7732 +       (and:SI (match_dup 1)
7733 +               (match_dup 2)))]
7734 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
7735 +  "@
7736 +   and.4\\t%0, %2, %1
7737 +   and.4\\t%0, %1, %2")
7738 +
7739 +(define_insn "andsi3_and4_ccwzn_null"
7740 +  [(set (reg CC_REGNO)
7741 +       (compare
7742 +         (and:SI (match_operand:SI 0 "nonimmediate_operand"    "%d,rm")
7743 +                 (match_operand:SI 1 "ubicom32_arith_operand" "rmI, d"))
7744 +         (const_int 0)))]
7745 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
7746 +  "@
7747 +   and.4\\t#0, %1, %0
7748 +   and.4\\t#0, %0, %1")
7749 +
7750 +(define_insn "andsi3_lsr4_ccwz_null"
7751 +  [(set (reg CC_REGNO)
7752 +       (compare
7753 +         (and:SI (match_operand:SI 0 "nonimmediate_operand" "%rm")
7754 +                 (match_operand:SI 1 "const_int_operand"      "n"))
7755 +         (const_int 0)))
7756 +   (clobber (match_scratch:SI 2                                      "=d"))]
7757 +  "(exact_log2 ((~(INTVAL (operands[1]))) + 1) != -1
7758 +    && ubicom32_match_cc_mode(insn, CCWZmode))"
7759 +  "*
7760 +   {
7761 +     operands[3] = GEN_INT (exact_log2 ((~(INTVAL (operands[1]))) + 1));
7762 +
7763 +     return \"lsr.4\\t%2, %0, %3\";
7764 +   }")
7765 +
7766 +; We really would like the combiner to recognize this scenario and deal with
7767 +; it but unfortunately it tries to canonicalize zero_extract ops on MEMs
7768 +; into QImode operations and we can't match them in any useful way.
7769 +;
7770 +(define_peephole2
7771 +  [(set (match_operand:SI 0 "register_operand" "")
7772 +       (match_operand:SI 1 "const_int_operand" ""))
7773 +   (set (reg:CCWZ CC_REGNO)
7774 +       (compare:CCWZ
7775 +         (and:SI (match_operand:SI 2 "nonimmediate_operand" "")
7776 +                 (match_dup 0))
7777 +         (const_int 0)))]
7778 +  "(exact_log2 (INTVAL (operands[1])) != -1
7779 +    && peep2_reg_dead_p (2, operands[0]))"
7780 +  [(set (reg:CCWZ CC_REGNO)
7781 +       (compare:CCWZ
7782 +         (zero_extract:SI
7783 +           (match_dup 2)
7784 +           (const_int 1)
7785 +           (match_dup 3))
7786 +         (const_int 0)))]
7787 +  "{
7788 +     operands[3] = GEN_INT (exact_log2 (INTVAL (operands[1])));
7789 +   }")
7790 +
7791 +(define_expand "anddi3"
7792 +  [(parallel
7793 +     [(set (match_operand:DI 0 "nonimmediate_operand" "")
7794 +          (and:DI (match_operand:DI 1 "nonimmediate_operand" "")
7795 +                  (match_operand:DI 2 "ubicom32_arith_operand" "")))
7796 +      (clobber (reg:CC CC_REGNO))])]
7797 +  ""
7798 +  "{
7799 +     /* If we have a non-data reg for operand 1 then prefer that over
7800 +        a CONST_INT in operand 2.  */
7801 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
7802 +        && CONST_INT_P (operands[2]))
7803 +       operands[2] = copy_to_mode_reg (DImode, operands[2]);
7804 +
7805 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
7806 +       operands[2] = copy_to_mode_reg (DImode, operands[2]);
7807 +   }")
7808 +
7809 +(define_insn_and_split "anddi3_and4"
7810 +  [(set (match_operand:DI 0 "nonimmediate_operand"          "=&r,&r,  d,rm,  m, m")
7811 +       (and:DI (match_operand:DI 1 "nonimmediate_operand"    "%d,rm,  0, 0,  d,rm")
7812 +               (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d,rmI, d,rmI, d")))
7813 +   (clobber (reg:CC CC_REGNO))]
7814 +  ""
7815 +  "#"
7816 +  "reload_completed"
7817 +  [(parallel [(set (match_dup 3)
7818 +                  (and:SI (match_dup 4)
7819 +                          (match_dup 5)))
7820 +             (clobber (reg:CC CC_REGNO))])
7821 +   (parallel [(set (match_dup 6)
7822 +                  (and:SI (match_dup 7)
7823 +                          (match_dup 8)))
7824 +             (clobber (reg:CC CC_REGNO))])]
7825 +  "{
7826 +     operands[3] = gen_lowpart (SImode, operands[0]);
7827 +     operands[4] = gen_lowpart (SImode, operands[1]);
7828 +     operands[5] = gen_lowpart (SImode, operands[2]);
7829 +     operands[6] = gen_highpart (SImode, operands[0]);
7830 +     operands[7] = gen_highpart (SImode, operands[1]);
7831 +     operands[8] = gen_highpart_mode (SImode, DImode, operands[2]);
7832 +   }"
7833 +  [(set_attr "length" "8")])
7834 +
7835 +(define_expand "iorqi3"
7836 +  [(parallel
7837 +     [(set (match_operand:QI 0 "memory_operand" "")
7838 +          (ior:QI (match_operand:QI 1 "nonimmediate_operand" "")
7839 +                  (match_operand:QI 2 "ubicom32_arith_operand" "")))
7840 +      (clobber (reg:CC CC_REGNO))])]
7841 +  "(ubicom32_v4)"
7842 +  "{
7843 +     if (!memory_operand (operands[0], QImode))
7844 +       FAIL;
7845 +
7846 +     /* If we have a non-data reg for operand 1 then prefer that over
7847 +        a CONST_INT in operand 2.  */
7848 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
7849 +        && CONST_INT_P (operands[2]))
7850 +       operands[2] = copy_to_mode_reg (QImode, operands[2]);
7851 +
7852 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
7853 +       operands[2] = copy_to_mode_reg (QImode, operands[2]);
7854 +   }")
7855 +
7856 +(define_insn "iorqi3_or1"
7857 +  [(set (match_operand:QI 0 "memory_operand"                 "=m, m")
7858 +       (ior:QI (match_operand:QI 1 "nonimmediate_operand"    "%d,rm")
7859 +               (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d")))
7860 +   (clobber (reg:CC CC_REGNO))]
7861 +  "(ubicom32_v4)"
7862 +  "@
7863 +   or.1\\t%0, %2, %1
7864 +   or.1\\t%0, %1, %2")
7865 +
7866 +(define_expand "iorhi3"
7867 +  [(parallel
7868 +     [(set (match_operand:HI 0 "memory_operand" "")
7869 +          (ior:HI (match_operand:HI 1 "nonimmediate_operand" "")
7870 +                  (match_operand:HI 2 "ubicom32_arith_operand" "")))
7871 +      (clobber (reg:CC CC_REGNO))])]
7872 +  ""
7873 +  "{
7874 +     if (!memory_operand (operands[0], HImode))
7875 +       FAIL;
7876 +
7877 +     /* If we have a non-data reg for operand 1 then prefer that over
7878 +        a CONST_INT in operand 2.  */
7879 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
7880 +        && CONST_INT_P (operands[2]))
7881 +       operands[2] = copy_to_mode_reg (HImode, operands[2]);
7882 +
7883 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
7884 +       operands[2] = copy_to_mode_reg (HImode, operands[2]);
7885 +   }")
7886 +
7887 +(define_insn "iorhi3_or2"
7888 +  [(set (match_operand:HI 0 "memory_operand"                 "=m, m")
7889 +       (ior:HI (match_operand:HI 1 "nonimmediate_operand"    "%d,rm")
7890 +               (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d")))
7891 +   (clobber (reg:CC CC_REGNO))]
7892 +  ""
7893 +  "@
7894 +   or.2\\t%0, %2, %1
7895 +   or.2\\t%0, %1, %2")
7896 +
7897 +(define_expand "iorsi3"
7898 +  [(parallel
7899 +     [(set (match_operand:SI 0 "nonimmediate_operand" "")
7900 +          (ior:SI (match_operand:SI 1 "nonimmediate_operand" "")
7901 +                  (match_operand:SI 2 "ubicom32_and_or_si3_operand" "")))
7902 +      (clobber (reg:CC CC_REGNO))])]
7903 +  ""
7904 +  "{
7905 +     do
7906 +       {
7907 +        /* Is this a bset?  */
7908 +        if (CONST_INT_P (operands[2])
7909 +            && exact_log2 (INTVAL (operands[2])) != -1)
7910 +          break;
7911 +
7912 +        /* Must be an or.4  */
7913 +        if (!ubicom32_data_register_operand (operands[1], SImode))
7914 +          operands[1] = copy_to_mode_reg (SImode, operands[1]);
7915 +
7916 +        if (!ubicom32_arith_operand (operands[2], SImode))
7917 +          operands[2] = copy_to_mode_reg (SImode, operands[2]);
7918 +       }
7919 +     while (0);
7920 +   }")
7921 +
7922 +(define_insn "iorsi3_bset"
7923 +  [(set (match_operand:SI 0 "nonimmediate_operand"           "=rm")
7924 +       (ior:SI (match_operand:SI 1 "ubicom32_arith_operand" "%rmI")
7925 +               (match_operand 2 "const_int_operand"            "n")))
7926 +   (clobber (reg:CC CC_REGNO))]
7927 +  "(exact_log2 (INTVAL (operands[2])) != -1)"
7928 +  "bset\\t%0, %1, #%d2")
7929 +
7930 +(define_insn "iorsi3_or4"
7931 +  [(set (match_operand:SI 0 "nonimmediate_operand"          "=rm,rm")
7932 +       (ior:SI (match_operand:SI 1 "nonimmediate_operand"    "%d,rm")
7933 +               (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d")))
7934 +   (clobber (reg:CC CC_REGNO))]
7935 +  ""
7936 +  "@
7937 +   or.4\\t%0, %2, %1
7938 +   or.4\\t%0, %1, %2")
7939 +
7940 +(define_insn "iorsi3_ccwzn"
7941 +  [(set (reg CC_REGNO)
7942 +       (compare
7943 +         (ior:SI (match_operand:SI 1 "nonimmediate_operand"    "%d,rm")
7944 +                 (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d"))
7945 +         (const_int 0)))
7946 +   (set (match_operand:SI 0 "nonimmediate_operand"            "=rm,rm")
7947 +       (ior:SI (match_dup 1)
7948 +               (match_dup 2)))]
7949 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
7950 +  "@
7951 +   or.4\\t%0, %2, %1
7952 +   or.4\\t%0, %1, %2")
7953 +
7954 +(define_insn "iorsi3_ccwzn_null"
7955 +  [(set (reg CC_REGNO)
7956 +       (compare
7957 +         (ior:SI (match_operand:SI 0 "nonimmediate_operand"    "%d,rm")
7958 +                 (match_operand:SI 1 "ubicom32_arith_operand" "rmI, d"))
7959 +         (const_int 0)))]
7960 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
7961 +  "@
7962 +   or.4\\t#0, %1, %0
7963 +   or.4\\t#0, %0, %1")
7964 +
7965 +(define_expand "iordi3"
7966 +  [(parallel
7967 +     [(set (match_operand:DI 0 "nonimmediate_operand" "")
7968 +          (ior:DI (match_operand:DI 1 "nonimmediate_operand" "")
7969 +                  (match_operand:DI 2 "ubicom32_arith_operand" "")))
7970 +      (clobber (reg:CC CC_REGNO))])]
7971 +  ""
7972 +  "{
7973 +     /* If we have a non-data reg for operand 1 then prefer that over
7974 +        a CONST_INT in operand 2.  */
7975 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
7976 +        && CONST_INT_P (operands[2]))
7977 +       operands[2] = copy_to_mode_reg (DImode, operands[2]);
7978 +
7979 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
7980 +       operands[2] = copy_to_mode_reg (DImode, operands[2]);
7981 +   }")
7982 +
7983 +(define_insn_and_split "iordi3_or4"
7984 +  [(set (match_operand:DI 0 "nonimmediate_operand"          "=&r,&r,  d,rm,  m, m")
7985 +       (ior:DI (match_operand:DI 1 "nonimmediate_operand"    "%d,rm,  0, 0,  d,rm")
7986 +               (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d,rmI, d,rmI, d")))
7987 +   (clobber (reg:CC CC_REGNO))]
7988 +  ""
7989 +  "#"
7990 +  "reload_completed"
7991 +  [(parallel [(set (match_dup 3)
7992 +                  (ior:SI (match_dup 4)
7993 +                          (match_dup 5)))
7994 +             (clobber (reg:CC CC_REGNO))])
7995 +   (parallel [(set (match_dup 6)
7996 +                  (ior:SI (match_dup 7)
7997 +                          (match_dup 8)))
7998 +             (clobber (reg:CC CC_REGNO))])]
7999 +  "{
8000 +     operands[3] = gen_lowpart (SImode, operands[0]);
8001 +     operands[4] = gen_lowpart (SImode, operands[1]);
8002 +     operands[5] = gen_lowpart (SImode, operands[2]);
8003 +     operands[6] = gen_highpart (SImode, operands[0]);
8004 +     operands[7] = gen_highpart (SImode, operands[1]);
8005 +     operands[8] = gen_highpart_mode (SImode, DImode, operands[2]);
8006 +   }"
8007 +  [(set_attr "length" "8")])
8008 +
8009 +(define_expand "xorqi3"
8010 +  [(parallel
8011 +     [(set (match_operand:QI 0 "memory_operand" "")
8012 +          (xor:QI (match_operand:QI 1 "nonimmediate_operand" "")
8013 +                  (match_operand:QI 2 "ubicom32_arith_operand" "")))
8014 +      (clobber (reg:CC CC_REGNO))])]
8015 +  "(ubicom32_v4)"
8016 +  "{
8017 +     if (!memory_operand (operands[0], QImode))
8018 +       FAIL;
8019 +
8020 +     /* If we have a non-data reg for operand 1 then prefer that over
8021 +        a CONST_INT in operand 2.  */
8022 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
8023 +        && CONST_INT_P (operands[2]))
8024 +       operands[2] = copy_to_mode_reg (QImode, operands[2]);
8025 +
8026 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
8027 +       operands[2] = copy_to_mode_reg (QImode, operands[2]);
8028 +   }")
8029 +
8030 +(define_insn "xorqi3_xor1"
8031 +  [(set (match_operand:QI 0 "memory_operand"                 "=m, m")
8032 +       (xor:QI (match_operand:QI 1 "nonimmediate_operand"    "%d,rm")
8033 +               (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d")))
8034 +   (clobber (reg:CC CC_REGNO))]
8035 +  "(ubicom32_v4)"
8036 +  "@
8037 +   xor.1\\t%0, %2, %1
8038 +   xor.1\\t%0, %1, %2")
8039 +
8040 +(define_insn "xorqi3_xor1_ccszn"
8041 +  [(set (reg CC_REGNO)
8042 +       (compare
8043 +         (xor:QI (match_operand:QI 1 "nonimmediate_operand"    "%d,rm")
8044 +                 (match_operand:QI 2 "ubicom32_arith_operand" "rmI, d"))
8045 +         (const_int 0)))
8046 +   (set (match_operand:QI 0 "memory_operand"                   "=m, m")
8047 +       (xor:QI (match_dup 1)
8048 +               (match_dup 2)))]
8049 +  "(ubicom32_v4
8050 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
8051 +  "@
8052 +   xor.1\\t%0, %2, %1
8053 +   xor.1\\t%0, %1, %2")
8054 +
8055 +(define_insn "xorqi3_xor1_ccszn_null"
8056 +  [(set (reg CC_REGNO)
8057 +       (compare
8058 +         (xor:QI (match_operand:QI 0 "nonimmediate_operand"    "%d,rm")
8059 +                 (match_operand:QI 1 "ubicom32_arith_operand" "rmI, d"))
8060 +         (const_int 0)))]
8061 +  "(ubicom32_v4
8062 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
8063 +  "@
8064 +   xor.1\\t#0, %1, %0
8065 +   xor.1\\t#0, %0, %1")
8066 +
8067 +(define_insn "xor1_ccszn_null_1"
8068 +  [(set (reg CC_REGNO)
8069 +       (compare
8070 +         (subreg:QI
8071 +           (xor:SI (match_operand:SI 0 "ubicom32_data_register_operand" "%d")
8072 +                   (match_operand:SI 1 "ubicom32_arith_operand"         "rI"))
8073 +           3)
8074 +         (const_int 0)))]
8075 +  "(ubicom32_v4
8076 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
8077 +  "xor.1\\t#0, %1, %0")
8078 +
8079 +(define_insn "xor1_ccszn_null_2"
8080 +  [(set (reg CC_REGNO)
8081 +       (compare
8082 +         (subreg:QI
8083 +           (xor:SI (match_operand:SI 0 "ubicom32_data_register_operand" "d")
8084 +                   (subreg:SI
8085 +                     (match_operand:QI 1 "memory_operand"               "m")
8086 +                     0))
8087 +           3)
8088 +         (const_int 0)))]
8089 +  "(ubicom32_v4
8090 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
8091 +  "xor.1\\t#0, %1, %0")
8092 +
8093 +(define_insn "xor1_ccwzn_null_3"
8094 +  [(set (reg CC_REGNO)
8095 +       (compare
8096 +         (subreg:QI
8097 +           (xor:SI (subreg:SI
8098 +                     (match_operand:QI 0 "memory_operand"               "m")
8099 +                     0)
8100 +                   (match_operand:SI 1 "ubicom32_data_register_operand" "d"))
8101 +           3)
8102 +         (const_int 0)))]
8103 +  "(ubicom32_v4
8104 +    && ubicom32_match_cc_mode(insn, CCSZNmode))"
8105 +  "xor.1\\t#0, %0, %1")
8106 +
8107 +(define_expand "xorhi3"
8108 +  [(parallel
8109 +     [(set (match_operand:HI 0 "memory_operand" "")
8110 +          (xor:HI (match_operand:HI 1 "nonimmediate_operand" "")
8111 +                  (match_operand:HI 2 "ubicom32_arith_operand" "")))
8112 +      (clobber (reg:CC CC_REGNO))])]
8113 +  ""
8114 +  "{
8115 +     if (!memory_operand (operands[0], HImode))
8116 +       FAIL;
8117 +
8118 +     /* If we have a non-data reg for operand 1 then prefer that over
8119 +        a CONST_INT in operand 2.  */
8120 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
8121 +        && CONST_INT_P (operands[2]))
8122 +       operands[2] = copy_to_mode_reg (HImode, operands[2]);
8123 +
8124 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
8125 +       operands[2] = copy_to_mode_reg (HImode, operands[2]);
8126 +   }")
8127 +
8128 +(define_insn "xorhi3_xor2"
8129 +  [(set (match_operand:HI 0 "memory_operand"                 "=m, m")
8130 +       (xor:HI (match_operand:HI 1 "nonimmediate_operand"    "%d,rm")
8131 +               (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d")))
8132 +   (clobber (reg:CC CC_REGNO))]
8133 +  ""
8134 +  "@
8135 +   xor.2\\t%0, %2, %1
8136 +   xor.2\\t%0, %1, %2")
8137 +
8138 +(define_insn "xorhi3_xor2_ccszn"
8139 +  [(set (reg CC_REGNO)
8140 +       (compare
8141 +         (xor:HI (match_operand:HI 1 "nonimmediate_operand"    "%d,rm")
8142 +                 (match_operand:HI 2 "ubicom32_arith_operand" "rmI, d"))
8143 +         (const_int 0)))
8144 +   (set (match_operand:HI 0 "memory_operand"                   "=m, m")
8145 +       (xor:HI (match_dup 1)
8146 +               (match_dup 2)))]
8147 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
8148 +  "@
8149 +   xor.2\\t%0, %2, %1
8150 +   xor.2\\t%0, %1, %2")
8151 +
8152 +(define_insn "xorhi3_xor2_ccszn_null"
8153 +  [(set (reg CC_REGNO)
8154 +       (compare
8155 +         (xor:HI (match_operand:HI 0 "nonimmediate_operand"    "%d,rm")
8156 +                 (match_operand:HI 1 "ubicom32_arith_operand" "rmI, d"))
8157 +         (const_int 0)))]
8158 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
8159 +  "@
8160 +   xor.2\\t#0, %1, %0
8161 +   xor.2\\t#0, %0, %1")
8162 +
8163 +(define_insn "xor2_ccszn_null_1"
8164 +  [(set (reg CC_REGNO)
8165 +       (compare
8166 +         (subreg:HI
8167 +           (xor:SI (match_operand:SI 0 "ubicom32_data_register_operand" "%d")
8168 +                   (match_operand:SI 1 "ubicom32_arith_operand"         "rI"))
8169 +           2)
8170 +         (const_int 0)))]
8171 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
8172 +  "xor.2\\t#0, %1, %0")
8173 +
8174 +(define_insn "xor2_ccszn_null_2"
8175 +  [(set (reg CC_REGNO)
8176 +       (compare
8177 +         (subreg:HI
8178 +           (xor:SI (match_operand:SI 0 "ubicom32_data_register_operand" "d")
8179 +                   (subreg:SI
8180 +                     (match_operand:HI 1 "memory_operand"               "m")
8181 +                     0))
8182 +           2)
8183 +         (const_int 0)))]
8184 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
8185 +  "xor.2\\t#0, %1, %0")
8186 +
8187 +(define_insn "xor2_ccszn_null_3"
8188 +  [(set (reg CC_REGNO)
8189 +       (compare
8190 +         (subreg:HI
8191 +           (xor:SI (subreg:SI
8192 +                     (match_operand:HI 0 "memory_operand"               "m")
8193 +                     0)
8194 +                   (match_operand:SI 1 "ubicom32_data_register_operand" "d"))
8195 +           2)
8196 +         (const_int 0)))]
8197 +  "ubicom32_match_cc_mode(insn, CCSZNmode)"
8198 +  "xor.2\\t#0, %0, %1")
8199 +
8200 +(define_insn "xorsi3"
8201 +  [(set (match_operand:SI 0 "nonimmediate_operand"          "=rm,rm")
8202 +       (xor:SI (match_operand:SI 1 "nonimmediate_operand"    "%d,rm")
8203 +               (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d")))
8204 +   (clobber (reg:CC CC_REGNO))]
8205 +  ""
8206 +  "@
8207 +   xor.4\\t%0, %2, %1
8208 +   xor.4\\t%0, %1, %2")
8209 +
8210 +(define_insn "xorsi3_ccwzn"
8211 +  [(set (reg CC_REGNO)
8212 +       (compare
8213 +         (xor:SI (match_operand:SI 1 "nonimmediate_operand"    "%d,rm")
8214 +                 (match_operand:SI 2 "ubicom32_arith_operand" "rmI, d"))
8215 +         (const_int 0)))
8216 +   (set (match_operand:SI 0 "nonimmediate_operand"            "=rm,rm")
8217 +       (xor:SI (match_dup 1)
8218 +               (match_dup 2)))]
8219 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
8220 +  "@
8221 +   xor.4\\t%0, %2, %1
8222 +   xor.4\\t%0, %1, %2")
8223 +
8224 +(define_insn "xorsi3_ccwzn_null"
8225 +  [(set (reg CC_REGNO)
8226 +       (compare
8227 +         (xor:SI (match_operand:SI 0 "nonimmediate_operand"    "%d,rm")
8228 +                 (match_operand:SI 1 "ubicom32_arith_operand" "rmI, d"))
8229 +         (const_int 0)))]
8230 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
8231 +  "@
8232 +   xor.4\\t#0, %1, %0
8233 +   xor.4\\t#0, %0, %1")
8234 +
8235 +(define_expand "xordi3"
8236 +  [(parallel
8237 +     [(set (match_operand:DI 0 "nonimmediate_operand" "")
8238 +          (xor:DI (match_operand:DI 1 "nonimmediate_operand" "")
8239 +                  (match_operand:DI 2 "ubicom32_arith_operand" "")))
8240 +      (clobber (reg:CC CC_REGNO))])]
8241 +  ""
8242 +  "{
8243 +     /* If we have a non-data reg for operand 1 then prefer that over
8244 +        a CONST_INT in operand 2.  */
8245 +     if (! ubicom32_data_register_operand (operands[1], GET_MODE (operands[1]))
8246 +        && CONST_INT_P (operands[2]))
8247 +       operands[2] = copy_to_mode_reg (DImode, operands[2]);
8248 +
8249 +     if (CONST_INT_P (operands[2]) && ! satisfies_constraint_I (operands[2]))
8250 +       operands[2] = copy_to_mode_reg (DImode, operands[2]);
8251 +   }")
8252 +
8253 +(define_insn_and_split "xordi3_xor4"
8254 +  [(set (match_operand:DI 0 "nonimmediate_operand"          "=&r,&r,  d,rm,  m, m")
8255 +       (xor:DI (match_operand:DI 1 "nonimmediate_operand"    "%d,rm,  0, 0,  d,rm")
8256 +               (match_operand:DI 2 "ubicom32_arith_operand" "rmI, d,rmI, d,rmI, d")))
8257 +   (clobber (reg:CC CC_REGNO))]
8258 +  ""
8259 +  "#"
8260 +  "reload_completed"
8261 +  [(parallel [(set (match_dup 3)
8262 +                  (xor:SI (match_dup 4)
8263 +                          (match_dup 5)))
8264 +             (clobber (reg:CC CC_REGNO))])
8265 +   (parallel [(set (match_dup 6)
8266 +                  (xor:SI (match_dup 7)
8267 +                          (match_dup 8)))
8268 +             (clobber (reg:CC CC_REGNO))])]
8269 +  "{
8270 +     operands[3] = gen_lowpart (SImode, operands[0]);
8271 +     operands[4] = gen_lowpart (SImode, operands[1]);
8272 +     operands[5] = gen_lowpart (SImode, operands[2]);
8273 +     operands[6] = gen_highpart (SImode, operands[0]);
8274 +     operands[7] = gen_highpart (SImode, operands[1]);
8275 +     operands[8] = gen_highpart_mode (SImode, DImode, operands[2]);
8276 +   }"
8277 +  [(set_attr "length" "8")])
8278 +
8279 +(define_insn "not2_2"
8280 +  [(set (match_operand:HI 0 "memory_operand"                   "=m")
8281 +       (subreg:HI
8282 +         (not:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI"))
8283 +         2))
8284 +   (clobber (reg:CC CC_REGNO))]
8285 +  ""
8286 +  "not.2\\t%0, %1")
8287 +
8288 +(define_insn "one_cmplsi2"
8289 +  [(set (match_operand:SI 0 "nonimmediate_operand"          "=rm")
8290 +       (not:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI")))
8291 +   (clobber (reg:CC CC_REGNO))]
8292 +  ""
8293 +  "not.4\\t%0, %1")
8294 +
8295 +(define_insn "one_cmplsi2_ccwzn"
8296 +  [(set (reg CC_REGNO)
8297 +       (compare
8298 +         (not:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI"))
8299 +         (const_int 0)))
8300 +   (set (match_operand:SI 0 "nonimmediate_operand"            "=rm")
8301 +       (not:SI (match_dup 1)))]
8302 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
8303 +  "not.4\\t%0, %1")
8304 +
8305 +(define_insn "one_cmplsi2_ccwzn_null"
8306 +  [(set (reg CC_REGNO)
8307 +       (compare
8308 +         (not:SI (match_operand:SI 0 "ubicom32_arith_operand" "rmI"))
8309 +         (const_int 0)))]
8310 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
8311 +  "not.4\\t#0, %0")
8312 +
8313 +(define_insn_and_split "one_cmpldi2"
8314 +  [(set (match_operand:DI 0 "nonimmediate_operand"        "=&rm")
8315 +       (not:DI (match_operand:DI 1 "nonimmediate_operand" "rmI0")))
8316 +   (clobber (reg:CC CC_REGNO))]
8317 +  ""
8318 +  "#"
8319 +  ""
8320 +  [(parallel [(set (match_dup 2)
8321 +                  (not:SI (match_dup 3)))
8322 +             (clobber (reg:CC CC_REGNO))])
8323 +   (parallel [(set (match_dup 4)
8324 +                  (not:SI (match_dup 5)))
8325 +             (clobber (reg:CC CC_REGNO))])]
8326 +  "{
8327 +     operands[2] = gen_lowpart (SImode, operands[0]);
8328 +     operands[3] = gen_lowpart (SImode, operands[1]);
8329 +     operands[4] = gen_highpart (SImode, operands[0]);
8330 +     operands[5] = gen_highpart (SImode, operands[1]);
8331 +   }"
8332 +  [(set_attr "length" "8")])
8333 +
8334 +; Conditional jump instructions
8335 +
8336 +(define_expand "beq"
8337 +  [(set (pc)
8338 +       (if_then_else (eq (match_dup 1)
8339 +                         (const_int 0))
8340 +                     (label_ref (match_operand 0 "" ""))
8341 +                     (pc)))]
8342 +  ""
8343 +  "{
8344 +     operands[1] = ubicom32_gen_compare_reg (EQ, ubicom32_compare_op0,
8345 +                                            ubicom32_compare_op1);
8346 +   }")
8347 +
8348 +(define_expand "bne"
8349 +  [(set (pc)
8350 +       (if_then_else (ne (match_dup 1)
8351 +                         (const_int 0))
8352 +                     (label_ref (match_operand 0 "" ""))
8353 +                     (pc)))]
8354 +  ""
8355 +  "{
8356 +     operands[1] = ubicom32_gen_compare_reg (NE, ubicom32_compare_op0,
8357 +                                            ubicom32_compare_op1);
8358 +   }")
8359 +
8360 +(define_expand "bgt"
8361 +  [(set (pc)
8362 +       (if_then_else (gt (match_dup 1)
8363 +                         (const_int 0))
8364 +                     (label_ref (match_operand 0 "" ""))
8365 +                     (pc)))]
8366 +  ""
8367 +  "{
8368 +     operands[1] = ubicom32_gen_compare_reg (GT, ubicom32_compare_op0,
8369 +                                            ubicom32_compare_op1);
8370 +   }")
8371 +
8372 +(define_expand "ble"
8373 +  [(set (pc)
8374 +       (if_then_else (le (match_dup 1)
8375 +                         (const_int 0))
8376 +                     (label_ref (match_operand 0 "" ""))
8377 +                     (pc)))]
8378 +  ""
8379 +  "{
8380 +     operands[1] = ubicom32_gen_compare_reg (LE, ubicom32_compare_op0,
8381 +                                            ubicom32_compare_op1);
8382 +   }")
8383 +
8384 +(define_expand "bge"
8385 +  [(set (pc)
8386 +       (if_then_else (ge (match_dup 1)
8387 +                         (const_int 0))
8388 +                     (label_ref (match_operand 0 "" ""))
8389 +                     (pc)))]
8390 +  ""
8391 +  "{
8392 +     operands[1] = ubicom32_gen_compare_reg (GE, ubicom32_compare_op0,
8393 +                                            ubicom32_compare_op1);
8394 +   }")
8395 +
8396 +(define_expand "blt"
8397 +  [(set (pc)
8398 +       (if_then_else (lt (match_dup 1)
8399 +                         (const_int 0))
8400 +                     (label_ref (match_operand 0 "" ""))
8401 +                     (pc)))]
8402 +  ""
8403 +  "{
8404 +     operands[1] = ubicom32_gen_compare_reg (LT, ubicom32_compare_op0,
8405 +                                            ubicom32_compare_op1);
8406 +   }")
8407 +
8408 +(define_expand "bgtu"
8409 +  [(set (pc)
8410 +       (if_then_else (gtu (match_dup 1)
8411 +                          (const_int 0))
8412 +                     (label_ref (match_operand 0 "" ""))
8413 +                     (pc)))]
8414 +  ""
8415 +  "{
8416 +     operands[1] = ubicom32_gen_compare_reg (GTU, ubicom32_compare_op0,
8417 +                                            ubicom32_compare_op1);
8418 +   }")
8419 +
8420 +(define_expand "bleu"
8421 +  [(set (pc)
8422 +       (if_then_else (leu (match_dup 1)
8423 +                          (const_int 0))
8424 +                     (label_ref (match_operand 0 "" ""))
8425 +                     (pc)))]
8426 +  ""
8427 +  "{
8428 +     operands[1] = ubicom32_gen_compare_reg (LEU, ubicom32_compare_op0,
8429 +                                            ubicom32_compare_op1);
8430 +   }")
8431 +
8432 +(define_expand "bgeu"
8433 +  [(set (pc)
8434 +       (if_then_else (geu (match_dup 1)
8435 +                          (const_int 0))
8436 +                     (label_ref (match_operand 0 "" ""))
8437 +                     (pc)))]
8438 +  ""
8439 +  "{
8440 +     operands[1] = ubicom32_gen_compare_reg (GEU, ubicom32_compare_op0,
8441 +                                            ubicom32_compare_op1);
8442 +   }")
8443 +
8444 +(define_expand "bltu"
8445 +  [(set (pc)
8446 +       (if_then_else (ltu (match_dup 1)
8447 +                          (const_int 0))
8448 +                     (label_ref (match_operand 0 "" ""))
8449 +                     (pc)))]
8450 +  ""
8451 +  "{
8452 +     operands[1] = ubicom32_gen_compare_reg (LTU, ubicom32_compare_op0,
8453 +                                            ubicom32_compare_op1);
8454 +   }")
8455 +
8456 +(define_insn "jcc"
8457 +  [(set (pc)
8458 +       (if_then_else (match_operator 1 "comparison_operator"
8459 +                       [(match_operand 2 "ubicom32_cc_register_operand" "")
8460 +                        (const_int 0)])
8461 +                     (label_ref (match_operand 0 "" ""))
8462 +                     (pc)))]
8463 +  ""
8464 +  "*
8465 +   {
8466 +     ubicom32_output_cond_jump (insn, operands[1], operands[0]);
8467 +     return \"\";
8468 +   }")
8469 +
8470 +; Reverse branch - reverse our comparison condition so that we can
8471 +; branch in the opposite sense.
8472 +;
8473 +(define_insn_and_split "jcc_reverse"
8474 +  [(set (pc)
8475 +       (if_then_else (match_operator 1 "comparison_operator"
8476 +                       [(match_operand 2 "ubicom32_cc_register_operand" "")
8477 +                        (const_int 0)])
8478 +                     (pc)
8479 +                     (label_ref (match_operand 0 "" ""))))]
8480 +  ""
8481 +  "#"
8482 +  "reload_completed"
8483 +  [(set (pc)
8484 +       (if_then_else (match_dup 3)
8485 +                     (label_ref (match_dup 0))
8486 +                     (pc)))]
8487 +  "{
8488 +     rtx cc_reg;
8489 +
8490 +     cc_reg = gen_rtx_REG (GET_MODE (operands[2]), CC_REGNO);
8491 +     operands[3] = gen_rtx_fmt_ee (reverse_condition (GET_CODE (operands[1])),
8492 +                                  GET_MODE (operands[1]),
8493 +                                  cc_reg,
8494 +                                  const0_rtx);
8495 +   }")
8496 +
8497 +(define_insn "jump"
8498 +  [(set (pc)
8499 +       (label_ref (match_operand 0 "" "")))]
8500 +  ""
8501 +  "jmpt\\t%l0")
8502 +
8503 +(define_expand "indirect_jump"
8504 +  [(parallel [(set (pc)
8505 +                  (match_operand:SI 0 "register_operand" ""))
8506 +             (clobber (match_dup 0))])]
8507 +  ""
8508 +  "")
8509 +
8510 +(define_insn "indirect_jump_internal"
8511 +  [(set (pc)
8512 +       (match_operand:SI 0 "register_operand" "a"))
8513 +  (clobber (match_dup 0))]
8514 +  ""
8515 +  "calli\\t%0,0(%0)")
8516 +
8517 +; Program Space: The table contains instructions, typically jumps.
8518 +; CALL An,TABLE_SIZE(PC)       ;An = Jump Table Base Address.
8519 +; <Jump Table is Here> ;An -> Here.
8520 +; LEA Ak, (An,Dn)      ;Ak -> Table Entry
8521 +; JMP/CALL (Ak)
8522 +
8523 +(define_expand "tablejump"
8524 +  [(parallel [(set (pc)
8525 +                  (match_operand:SI 0 "nonimmediate_operand" ""))
8526 +             (use (label_ref (match_operand 1 "" "")))])]
8527 +  ""
8528 +  "")
8529 +
8530 +(define_insn "tablejump_internal"
8531 +  [(set (pc)
8532 +       (match_operand:SI 0 "nonimmediate_operand" "rm"))
8533 +   (use (label_ref (match_operand 1 "" "")))]
8534 +  ""
8535 +  "ret\\t%0")
8536 +
8537 +; Call subroutine with no return value.
8538 +;
8539 +(define_expand "call"
8540 +  [(call (match_operand:QI 0 "general_operand" "")
8541 +        (match_operand:SI 1 "general_operand" ""))]
8542 +  ""
8543 +  "{
8544 +     if (TARGET_FDPIC)
8545 +       {
8546 +        ubicom32_expand_call_fdpic (operands);
8547 +        DONE;
8548 +       }
8549 +
8550 +     if (! ubicom32_call_address_operand (XEXP (operands[0], 0), VOIDmode))
8551 +       XEXP (operands[0], 0) = force_reg (SImode, XEXP (operands[0], 0));
8552 +   }")
8553 +
8554 +; We expand to a simple form that doesn't clobber the link register and
8555 +; then split to a form that does.  This allows the RTL optimizers that
8556 +; run before the splitter to have the opportunity to eliminate the call
8557 +; without marking A5 as being clobbered and this in turn avoids saves
8558 +; and returns in a number of cases.
8559 +;
8560 +(define_insn_and_split "call_1"
8561 +  [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S"))
8562 +        (match_operand:SI 1 "general_operand"                       "g,g"))]
8563 +  "! TARGET_FDPIC"
8564 +  "#"
8565 +  ""
8566 +  [(parallel
8567 +     [(call (mem:QI (match_dup 0))
8568 +           (match_dup 1))
8569 +      (clobber (reg:SI LINK_REGNO))])]
8570 +  "")
8571 +
8572 +(define_insn "call_slow"
8573 +  [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S"))
8574 +        (match_operand:SI 1 "general_operand"                       "g,g"))
8575 +   (clobber (reg:SI LINK_REGNO))]
8576 +  "(! TARGET_FDPIC && ! TARGET_FASTCALL)"
8577 +  "@
8578 +   calli\\ta5, 0(%0)
8579 +   moveai\\ta5, #%%hi(%C0)\;calli\\ta5, %%lo(%C0)(a5)")
8580 +
8581 +(define_insn "call_fast"
8582 +  [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S"))
8583 +        (match_operand:SI 1 "general_operand"                       "g,g"))
8584 +   (clobber (reg:SI LINK_REGNO))]
8585 +  "(! TARGET_FDPIC && TARGET_FASTCALL)"
8586 +  "@
8587 +   calli\\ta5, 0(%0)
8588 +   call\\ta5, %C0")
8589 +
8590 +; We expand to a simple form that doesn't clobber the link register and
8591 +; then split to a form that does.  This allows the RTL optimizers that
8592 +; run before the splitter to have the opportunity to eliminate the call
8593 +; without marking A5 as being clobbered and this in turn avoids saves
8594 +; and returns in a number of cases.
8595 +;
8596 +(define_insn_and_split "call_fdpic"
8597 +  [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S"))
8598 +        (match_operand:SI 1 "general_operand"                       "g,g"))
8599 +   (use (match_operand:SI 2 "ubicom32_fdpic_operand"                "Z,Z"))]
8600 +  "TARGET_FDPIC"
8601 +  "#"
8602 +  ""
8603 +  [(parallel
8604 +     [(call (mem:QI (match_dup 0))
8605 +           (match_dup 1))
8606 +      (use (match_dup 2))
8607 +      (clobber (reg:SI LINK_REGNO))])]
8608 +  "")
8609 +
8610 +(define_insn "call_fdpic_clobber"
8611 +  [(call (mem:QI (match_operand:SI 0 "ubicom32_call_address_operand" "a,S"))
8612 +        (match_operand:SI 1 "general_operand"                       "g,g"))
8613 +   (use (match_operand:SI 2 "ubicom32_fdpic_operand"                "Z,Z"))
8614 +   (clobber (reg:SI LINK_REGNO))]
8615 +  "TARGET_FDPIC"
8616 +  "@
8617 +   move.4\\ta5, 0(%0)\;move.4\\t%2, 4(%0)\;calli\\ta5, 0(a5)
8618 +   call\\ta5, %C0")
8619 +
8620 +; Call subroutine, returning value in operand 0
8621 +; (which must be a hard register).
8622 +;
8623 +(define_expand "call_value"
8624 +  [(set (match_operand 0 "" "")
8625 +       (call (match_operand:QI 1 "general_operand" "")
8626 +             (match_operand:SI 2 "general_operand" "")))]
8627 +  ""
8628 +  "{
8629 +     if (TARGET_FDPIC)
8630 +       {
8631 +        ubicom32_expand_call_value_fdpic (operands);
8632 +        DONE;
8633 +       }
8634 +
8635 +     if (! ubicom32_call_address_operand (XEXP (operands[1], 0), VOIDmode))
8636 +       XEXP (operands[1], 0) = force_reg (SImode, XEXP (operands[1], 0));
8637 +   }")
8638 +
8639 +; We expand to a simple form that doesn't clobber the link register and
8640 +; then split to a form that does.  This allows the RTL optimizers that
8641 +; run before the splitter to have the opportunity to eliminate the call
8642 +; without marking A5 as being clobbered and this in turn avoids saves
8643 +; and returns in a number of cases.
8644 +;
8645 +(define_insn_and_split "call_value_1"
8646 +  [(set (match_operand 0 "register_operand"                             "=r,r")
8647 +       (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S"))
8648 +             (match_operand:SI 2 "general_operand"                       "g,g")))]
8649 +  "! TARGET_FDPIC"
8650 +  "#"
8651 +  ""
8652 +  [(parallel
8653 +     [(set (match_dup 0)
8654 +          (call (mem:QI (match_dup 1))
8655 +                (match_dup 2)))
8656 +      (clobber (reg:SI LINK_REGNO))])]
8657 +  "")
8658 +
8659 +(define_insn "call_value_slow"
8660 +  [(set (match_operand 0 "register_operand"                             "=r,r")
8661 +       (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S"))
8662 +             (match_operand:SI 2 "general_operand"                       "g,g")))
8663 +   (clobber (reg:SI LINK_REGNO))]
8664 +  "(! TARGET_FDPIC && ! TARGET_FASTCALL)"
8665 +  "@
8666 +   calli\\ta5, 0(%1)
8667 +   moveai\\ta5, #%%hi(%C1)\;calli\\ta5, %%lo(%C1)(a5)")
8668 +
8669 +(define_insn "call_value_fast"
8670 +  [(set (match_operand 0 "register_operand"                             "=r,r")
8671 +       (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S"))
8672 +             (match_operand:SI 2 "general_operand"                       "g,g")))
8673 +   (clobber (reg:SI LINK_REGNO))]
8674 +  "(! TARGET_FDPIC && TARGET_FASTCALL)"
8675 +  "@
8676 +   calli\\ta5, 0(%1)
8677 +   call\\ta5, %C1")
8678 +
8679 +; We expand to a simple form that doesn't clobber the link register and
8680 +; then split to a form that does.  This allows the RTL optimizers that
8681 +; run before the splitter to have the opportunity to eliminate the call
8682 +; without marking A5 as being clobbered and this in turn avoids saves
8683 +; and returns in a number of cases.
8684 +;
8685 +(define_insn_and_split "call_value_fdpic"
8686 +  [(set (match_operand 0 "register_operand"                             "=r,r")
8687 +       (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S"))
8688 +             (match_operand:SI 2 "general_operand"                       "g,g")))
8689 +   (use (match_operand:SI 3 "ubicom32_fdpic_operand"                     "Z,Z"))]
8690 +  "TARGET_FDPIC"
8691 +  "#"
8692 +  ""
8693 +  [(parallel
8694 +     [(set (match_dup 0)
8695 +          (call (mem:QI (match_dup 1))
8696 +                (match_dup 2)))
8697 +      (use (match_dup 3))
8698 +      (clobber (reg:SI LINK_REGNO))])]
8699 +  "")
8700 +
8701 +(define_insn "call_value_fdpic_clobber"
8702 +  [(set (match_operand 0 "register_operand"                             "=r,r")
8703 +       (call (mem:QI (match_operand:SI 1 "ubicom32_call_address_operand" "a,S"))
8704 +             (match_operand:SI 2 "general_operand"                       "g,g")))
8705 +   (use (match_operand:SI 3 "ubicom32_fdpic_operand"                     "Z,Z"))
8706 +   (clobber (reg:SI LINK_REGNO))]
8707 +  "TARGET_FDPIC"
8708 +  "@
8709 +   move.4\\ta5, 0(%1)\;move.4\\t%3, 4(%1)\;calli\\ta5, 0(a5)
8710 +   call\\ta5, %C1")
8711 +
8712 +(define_expand "untyped_call"
8713 +  [(parallel [(call (match_operand 0 "" "")
8714 +                    (const_int 0))
8715 +              (match_operand 1 "" "")
8716 +              (match_operand 2 "" "")])]
8717 +  ""
8718 +  "{
8719 +     int i;
8720 +
8721 +     emit_call_insn (gen_call (operands[0], const0_rtx));
8722 +
8723 +     for (i = 0; i < XVECLEN (operands[2], 0); i++)
8724 +       {
8725 +         rtx set = XVECEXP (operands[2], 0, i);
8726 +         emit_move_insn (SET_DEST (set), SET_SRC (set));
8727 +       }
8728 +     DONE;
8729 +   }")
8730 +
8731 +(define_insn "lsl1_1"
8732 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"    "=d")
8733 +       (ashift:SI (subreg:SI
8734 +                    (match_operand:QI 1 "memory_operand"         "m")
8735 +                    0)
8736 +                  (match_operand:SI 2 "ubicom32_arith_operand"  "dM")))
8737 +   (clobber (reg:CC CC_REGNO))]
8738 +  "(ubicom32_v4)"
8739 +  "lsl.1\\t%0, %1, %2")
8740 +
8741 +; The combiner gets rather creative about left shifts of sub-word memory
8742 +; operands because it's uncertain about whether the memory is sign or
8743 +; zero extended.  It only wants zero-extended behaviour and so throws
8744 +; in an extra and operation.
8745 +;
8746 +(define_insn "lsl1_2"
8747 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d")
8748 +       (and:SI
8749 +         (ashift:SI (subreg:SI
8750 +                      (match_operand:QI 1 "memory_operand"   "m")
8751 +                      0)
8752 +                    (match_operand:SI 2 "const_int_operand"  "M"))
8753 +         (match_operand:SI 3 "const_int_operand"             "n")))
8754 +   (clobber (reg:CC CC_REGNO))]
8755 +  "(ubicom32_v4
8756 +    && INTVAL (operands[3]) == (0xff << INTVAL (operands[2])))"
8757 +  "lsl.1\\t%0, %1, %2")
8758 +
8759 +(define_insn "lsl2_1"
8760 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"    "=d")
8761 +       (ashift:SI (subreg:SI
8762 +                    (match_operand:HI 1 "memory_operand"         "m")
8763 +                    0)
8764 +                  (match_operand:SI 2 "ubicom32_arith_operand"  "dM")))
8765 +   (clobber (reg:CC CC_REGNO))]
8766 +  "(ubicom32_v4)"
8767 +  "lsl.2\\t%0, %1, %2")
8768 +
8769 +; The combiner gets rather creative about left shifts of sub-word memory
8770 +; operands because it's uncertain about whether the memory is sign or
8771 +; zero extended.  It only wants zero-extended behaviour and so throws
8772 +; in an extra and operation.
8773 +;
8774 +(define_insn "lsl2_2"
8775 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand" "=d")
8776 +       (and:SI
8777 +         (ashift:SI (subreg:SI
8778 +                      (match_operand:HI 1 "memory_operand"   "m")
8779 +                      0)
8780 +                    (match_operand:SI 2 "const_int_operand"  "M"))
8781 +         (match_operand:SI 3 "const_int_operand"             "n")))
8782 +   (clobber (reg:CC CC_REGNO))]
8783 +  "(ubicom32_v4
8784 +    && INTVAL (operands[3]) == (0xffff << INTVAL (operands[2])))"
8785 +  "lsl.2\\t%0, %1, %2")
8786 +
8787 +(define_insn "ashlsi3"
8788 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"    "=d")
8789 +       (ashift:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI")
8790 +                  (match_operand:SI 2 "ubicom32_arith_operand"  "dM")))
8791 +   (clobber (reg:CC CC_REGNO))]
8792 +  ""
8793 +  "lsl.4\\t%0, %1, %2")
8794 +
8795 +(define_insn "lshlsi3_ccwz"
8796 +  [(set (reg CC_REGNO)
8797 +       (compare
8798 +         (ashift:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI")
8799 +                    (match_operand:SI 2 "ubicom32_arith_operand"  "dM"))
8800 +         (const_int 0)))
8801 +   (set (match_operand:SI 0 "ubicom32_data_register_operand"      "=d")
8802 +       (ashift:SI (match_dup 1)
8803 +                  (match_dup 2)))]
8804 +  "ubicom32_match_cc_mode(insn, CCWZmode)"
8805 +  "lsl.4\\t%0, %1, %2")
8806 +
8807 +(define_insn "lshlsi3_ccwz_null"
8808 +  [(set (reg CC_REGNO)
8809 +       (compare
8810 +         (ashift:SI (match_operand:SI 0 "ubicom32_arith_operand" "rmI")
8811 +                    (match_operand:SI 1 "ubicom32_arith_operand"  "dM"))
8812 +         (const_int 0)))
8813 +   (clobber (match_scratch:SI 2                                           "=d"))]
8814 +  "ubicom32_match_cc_mode(insn, CCWZmode)"
8815 +  "lsl.4\\t%2, %0, %1")
8816 +
8817 +; The combiner finds this canonical form for what is in essence a right
8818 +; shift.
8819 +;
8820 +(define_insn "asr1_2"
8821 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"    "=d")
8822 +       (sign_extract:SI (match_operand:QI 1 "memory_operand"     "m")
8823 +                        (match_operand:SI 2 "const_int_operand"  "M")
8824 +                        (match_operand:SI 3 "const_int_operand"  "M")))
8825 +   (clobber (reg:CC CC_REGNO))]
8826 +  "(ubicom32_v4
8827 +    && (INTVAL (operands[2]) + INTVAL (operands[3]) == 8))"
8828 +  "asr.1\\t%0, %1, %3")
8829 +
8830 +; The combiner finds this canonical form for what is in essence a right
8831 +; shift.
8832 +;
8833 +(define_insn "asr2_2"
8834 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"    "=d")
8835 +       (sign_extract:SI (match_operand:HI 1 "memory_operand"     "m")
8836 +                        (match_operand:SI 2 "const_int_operand"  "M")
8837 +                        (match_operand:SI 3 "const_int_operand"  "M")))
8838 +   (clobber (reg:CC CC_REGNO))]
8839 +  "(ubicom32_v4
8840 +    && (INTVAL (operands[2]) + INTVAL (operands[3]) == 16))"
8841 +  "asr.2\\t%0, %1, %3")
8842 +
8843 +(define_insn "ashrsi3"
8844 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"      "=d")
8845 +       (ashiftrt:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmJ")
8846 +                    (match_operand:SI 2 "ubicom32_arith_operand"  "dM")))
8847 +   (clobber (reg:CC CC_REGNO))]
8848 +  ""
8849 +  "asr.4\\t%0, %1, %2")
8850 +
8851 +(define_insn "ashrsi3_ccwzn"
8852 +  [(set (reg CC_REGNO)
8853 +       (compare
8854 +         (ashiftrt:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmJ")
8855 +                      (match_operand:SI 2 "ubicom32_arith_operand"  "dM"))
8856 +         (const_int 0)))
8857 +   (set (match_operand:SI 0 "ubicom32_data_register_operand"        "=d")
8858 +       (ashiftrt:SI (match_dup 1)
8859 +                    (match_dup 2)))]
8860 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
8861 +  "asr.4\\t%0, %1, %2")
8862 +
8863 +(define_insn "ashrsi3_ccwzn_null"
8864 +  [(set (reg CC_REGNO)
8865 +       (compare
8866 +         (ashiftrt:SI (match_operand:SI 0 "ubicom32_arith_operand" "rmJ")
8867 +                      (match_operand:SI 1 "ubicom32_arith_operand"  "dM"))
8868 +         (const_int 0)))
8869 +   (clobber (match_scratch:SI 2                                             "=d"))]
8870 +  "ubicom32_match_cc_mode(insn, CCWZNmode)"
8871 +  "asr.4\\t%2, %0, %1")
8872 +
8873 +(define_insn "lsr1_1"
8874 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"    "=d")
8875 +       (lshiftrt:SI (subreg:SI
8876 +                      (match_operand:QI 1 "memory_operand"       "m")
8877 +                      0)
8878 +                  (match_operand:SI 2 "ubicom32_arith_operand"  "dM")))
8879 +   (clobber (reg:CC CC_REGNO))]
8880 +  "(ubicom32_v4)"
8881 +  "lsr.1\\t%0, %1, %2")
8882 +
8883 +; The combiner finds this canonical form for what is in essence a right
8884 +; shift.
8885 +;
8886 +(define_insn "lsr1_2"
8887 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"    "=d")
8888 +       (zero_extract:SI (match_operand:QI 1 "memory_operand"     "m")
8889 +                        (match_operand:SI 2 "const_int_operand"  "M")
8890 +                        (match_operand:SI 3 "const_int_operand"  "M")))
8891 +   (clobber (reg:CC CC_REGNO))]
8892 +  "(ubicom32_v4
8893 +    && (INTVAL (operands[2]) + INTVAL (operands[3]) == 8))"
8894 +  "lsr.1\\t%0, %1, %3")
8895 +
8896 +(define_insn "lsr2_1"
8897 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"    "=d")
8898 +       (lshiftrt:SI (subreg:SI
8899 +                      (match_operand:HI 1 "memory_operand"       "m")
8900 +                      0)
8901 +                  (match_operand:SI 2 "ubicom32_arith_operand"  "dM")))
8902 +   (clobber (reg:CC CC_REGNO))]
8903 +  "(ubicom32_v4)"
8904 +  "lsr.2\\t%0, %1, %2")
8905 +
8906 +; The combiner finds this canonical form for what is in essence a right
8907 +; shift.
8908 +;
8909 +(define_insn "lsr2_2"
8910 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"    "=d")
8911 +       (zero_extract:SI (match_operand:HI 1 "memory_operand"     "m")
8912 +                        (match_operand:SI 2 "const_int_operand"  "M")
8913 +                        (match_operand:SI 3 "const_int_operand"  "M")))
8914 +   (clobber (reg:CC CC_REGNO))]
8915 +  "(ubicom32_v4
8916 +    && (INTVAL (operands[2]) + INTVAL (operands[3]) == 16))"
8917 +  "lsr.2\\t%0, %1, %3")
8918 +
8919 +(define_insn "lshrsi3"
8920 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"      "=d")
8921 +       (lshiftrt:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI")
8922 +                    (match_operand:SI 2 "ubicom32_arith_operand"  "dM")))
8923 +   (clobber (reg:CC CC_REGNO))]
8924 +  ""
8925 +  "lsr.4\\t%0, %1, %2")
8926 +
8927 +(define_insn "lshrsi3_ccwz"
8928 +  [(set (reg CC_REGNO)
8929 +       (compare
8930 +         (lshiftrt:SI (match_operand:SI 1 "ubicom32_arith_operand" "rmI")
8931 +                      (match_operand:SI 2 "ubicom32_arith_operand"  "dM"))
8932 +         (const_int 0)))
8933 +   (set (match_operand:SI 0 "ubicom32_data_register_operand"        "=d")
8934 +       (lshiftrt:SI (match_dup 1)
8935 +                    (match_dup 2)))]
8936 +  "ubicom32_match_cc_mode(insn, CCWZmode)"
8937 +  "lsr.4\\t%0, %1, %2")
8938 +
8939 +(define_insn "lshrsi3_ccwz_null"
8940 +  [(set (reg CC_REGNO)
8941 +       (compare
8942 +         (lshiftrt:SI (match_operand:SI 0 "ubicom32_arith_operand" "rmI")
8943 +                      (match_operand:SI 1 "ubicom32_arith_operand"  "dM"))
8944 +         (const_int 0)))
8945 +   (clobber (match_scratch:SI 2                                             "=d"))]
8946 +  "ubicom32_match_cc_mode(insn, CCWZmode)"
8947 +  "lsr.4\\t%2, %0, %1")
8948 +
8949 +(define_expand "prologue"
8950 +  [(const_int 0)]
8951 +  ""
8952 +  "{
8953 +     ubicom32_expand_prologue ();
8954 +     DONE;
8955 +   }")
8956 +
8957 +(define_expand "epilogue"
8958 +  [(return)]
8959 +  ""
8960 +  "{
8961 +     ubicom32_expand_epilogue ();
8962 +     DONE;
8963 +   }")
8964 +
8965 +(define_expand "return"
8966 +  [(return)]
8967 +  ""
8968 +  "{
8969 +     ubicom32_expand_epilogue ();
8970 +     DONE;
8971 +   }")
8972 +
8973 +(define_expand "_eh_return"
8974 +  [(use (match_operand:SI 0 "register_operand" "r"))
8975 +   (use (match_operand:SI 1 "register_operand" "r"))]
8976 +  ""
8977 +  "{
8978 +     ubicom32_expand_eh_return (operands);
8979 +     DONE;
8980 +   }")
8981 +
8982 +; XXX - it looks almost certain that we could make return_internal use a Dn
8983 +; register too.  In that instance we'd have to use a ret instruction
8984 +; rather than a calli but it might save cycles.
8985 +;
8986 +(define_insn "return_internal"
8987 +  [(const_int 2)
8988 +   (return)
8989 +   (use (match_operand:SI 0 "ubicom32_mem_or_address_register_operand" "rm"))]
8990 +  ""
8991 +  "*
8992 +   {
8993 +     if (REG_P (operands[0]) && REGNO (operands[0]) == LINK_REGNO
8994 +        && ubicom32_can_use_calli_to_ret)
8995 +       return \"calli\\t%0, 0(%0)\";
8996 +
8997 +     return \"ret\\t%0\";
8998 +   }")
8999 +
9000 +(define_insn "return_from_post_modify_sp"
9001 +  [(parallel
9002 +     [(const_int 2)
9003 +      (return)
9004 +      (use (mem:SI (post_modify:SI
9005 +                    (reg:SI SP_REGNO)
9006 +                    (plus:SI (reg:SI SP_REGNO)
9007 +                             (match_operand:SI 0 "const_int_operand" "n")))))])]
9008 +  "INTVAL (operands[0]) >= 4 && INTVAL (operands[0]) <= 7 * 4"
9009 +  "ret\\t(sp)%E0++")
9010 +
9011 +;(define_insn "eh_return_internal"
9012 +;  [(const_int 4)
9013 +;   (return)
9014 +;   (use (reg:SI 34))]
9015 +;  ""
9016 +;  "ret\\ta2")
9017 +
9018 +; No operation, needed in case the user uses -g but not -O.
9019 +(define_expand "nop"
9020 +  [(const_int 0)]
9021 +  ""
9022 +  "")
9023 +
9024 +(define_insn "nop_internal"
9025 +  [(const_int 0)]
9026 +  ""
9027 +  "nop")
9028 +
9029 +; The combiner will generate this pattern given shift and add operations.
9030 +; The canonical form that the combiner wants to use appears to be multiplies
9031 +; instead of shifts even if the compiled sources use shifts.
9032 +;
9033 +(define_insn "shmrg1_add"
9034 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"          "=d")
9035 +       (plus:SI
9036 +         (mult:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d")
9037 +                  (const_int 256))
9038 +         (zero_extend:SI
9039 +           (match_operand:QI 2 "ubicom32_arith_operand"              "rmI"))))
9040 +   (clobber (reg:CC CC_REGNO))]
9041 +  ""
9042 +  "shmrg.1\\t%0, %2, %1")
9043 +
9044 +; The combiner will generate this pattern given shift and or operations.
9045 +;
9046 +(define_insn "shmrg1_ior"
9047 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"            "=d")
9048 +       (ior:SI
9049 +         (ashift:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d")
9050 +                    (const_int 8))
9051 +         (zero_extend:SI
9052 +           (match_operand:QI 2 "ubicom32_arith_operand"                "rmI"))))
9053 +   (clobber (reg:CC CC_REGNO))]
9054 +  ""
9055 +  "shmrg.1\\t%0, %2, %1")
9056 +
9057 +; The combiner will generate this pattern given shift and add operations.
9058 +; The canonical form that the combiner wants to use appears to be multiplies
9059 +; instead of shifts even if the compiled sources use shifts.
9060 +;
9061 +(define_insn "shmrg2_add"
9062 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"          "=d")
9063 +       (plus:SI
9064 +         (mult:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d")
9065 +                  (const_int 65536))
9066 +         (zero_extend:SI
9067 +           (match_operand:HI 2 "ubicom32_arith_operand"              "rmI"))))
9068 +   (clobber (reg:CC CC_REGNO))]
9069 +  ""
9070 +  "shmrg.2\\t%0, %2, %1")
9071 +
9072 +; The combiner will generate this pattern given shift and or operations.
9073 +;
9074 +(define_insn "shmrg2_ior"
9075 +  [(set (match_operand:SI 0 "ubicom32_data_register_operand"            "=d")
9076 +       (ior:SI
9077 +         (ashift:SI (match_operand:SI 1 "ubicom32_data_register_operand" "d")
9078 +                    (const_int 16))
9079 +         (zero_extend:SI
9080 +           (match_operand:HI 2 "ubicom32_arith_operand"                "rmI"))))
9081 +   (clobber (reg:CC CC_REGNO))]
9082 +  ""
9083 +  "shmrg.2\\t%0, %2, %1")
9084 +
9085 +; Match the case where we load a word from the stack but then discard the
9086 +; upper 16 bits.  We turn this into a zero-extended load of that useful
9087 +; 16 bits direct from the stack where possible.
9088 +;
9089 +
9090 +; XXX - do these peephole2 ops actually work after the CCmode conversion?
9091 +(define_peephole2
9092 +  [(set (match_operand:SI 0 "register_operand" "")
9093 +       (mem:SI (plus:SI (reg:SI SP_REGNO)
9094 +                        (match_operand:SI 1 "const_int_operand" ""))))
9095 +   (set (match_operand:SI 2 "nonimmediate_operand" "")
9096 +       (zero_extend:SI (match_operand:HI 3 "register_operand" "")))]
9097 +  "(INTVAL (operands[1]) <= 252
9098 +    && REGNO (operands[3]) == REGNO (operands[0])
9099 +    && ((peep2_reg_dead_p (2, operands[0])
9100 +        && ! reg_mentioned_p (operands[0], operands[2]))
9101 +        || rtx_equal_p (operands[0], operands[2])))"
9102 +  [(set (match_dup 2)
9103 +       (zero_extend:SI (mem:HI (plus:SI (reg:SI SP_REGNO)
9104 +                                        (match_dup 4)))))]
9105 +  "{
9106 +     operands[4] = GEN_INT (INTVAL (operands[1]) + 2);
9107 +   }")
9108 +
9109 +; Match the case where we load a word from the stack but then discard the
9110 +; upper 16 bits.  We turn this into a 16-bit load of that useful
9111 +; 16 bits direct from the stack where possible.
9112 +;
9113 +(define_peephole2
9114 +  [(set (match_operand:SI 0 "register_operand" "")
9115 +       (mem:SI (plus:SI (reg:SI SP_REGNO)
9116 +                        (match_operand:SI 1 "const_int_operand" ""))))
9117 +   (set (match_operand:HI 2 "nonimmediate_operand" "")
9118 +       (match_operand:HI 3 "register_operand" ""))]
9119 +  "(INTVAL (operands[1]) <= 252
9120 +    && REGNO (operands[3]) == REGNO (operands[0])
9121 +    && ((peep2_reg_dead_p (2, operands[0])
9122 +        && ! reg_mentioned_p (operands[0], operands[2]))
9123 +        || rtx_equal_p (operands[0], operands[2])))"
9124 +  [(set (match_dup 2)
9125 +       (mem:HI (plus:SI (reg:SI SP_REGNO)
9126 +                        (match_dup 4))))]
9127 +  "{
9128 +     operands[4] = GEN_INT (INTVAL (operands[1]) + 2);
9129 +   }")
9130 +
9131 +; Match the case where we load a word from the stack but then discard the
9132 +; upper 24 bits.  We turn this into a zero-extended load of that useful
9133 +; 8 bits direct from the stack where possible.
9134 +;
9135 +(define_peephole2
9136 +  [(set (match_operand:SI 0 "register_operand" "")
9137 +       (mem:SI (plus:SI (reg:SI SP_REGNO)
9138 +                        (match_operand:SI 1 "const_int_operand" ""))))
9139 +   (set (match_operand:SI 2 "nonimmediate_operand" "")
9140 +       (zero_extend:SI (match_operand:QI 3 "register_operand" "")))]
9141 +  "(INTVAL (operands[1]) <= 124
9142 +    && REGNO (operands[3]) == REGNO (operands[0])
9143 +    && ((peep2_reg_dead_p (2, operands[0])
9144 +        && ! reg_mentioned_p (operands[0], operands[2]))
9145 +        || rtx_equal_p (operands[0], operands[2])))"
9146 +  [(set (match_dup 2)
9147 +       (zero_extend:SI (mem:QI (plus:SI (reg:SI SP_REGNO)
9148 +                                        (match_dup 4)))))]
9149 +  "{
9150 +     operands[4] = GEN_INT (INTVAL (operands[1]) + 3);
9151 +   }")
9152 +
9153 +; Match the case where we load a word from the stack but then discard the
9154 +; upper 24 bits.  We turn this into an 8-bit load of that useful
9155 +; 8 bits direct from the stack where possible.
9156 +;
9157 +(define_peephole2
9158 +  [(set (match_operand:SI 0 "register_operand" "")
9159 +       (mem:SI (plus:SI (reg:SI SP_REGNO)
9160 +                        (match_operand:SI 1 "const_int_operand" ""))))
9161 +   (set (match_operand:QI 2 "nonimmediate_operand" "")
9162 +       (match_operand:QI 3 "register_operand" ""))]
9163 +  "(INTVAL (operands[1]) <= 124
9164 +    && REGNO (operands[3]) == REGNO (operands[0])
9165 +    && ((peep2_reg_dead_p (2, operands[0])
9166 +        && ! reg_mentioned_p (operands[0], operands[2]))
9167 +        || rtx_equal_p (operands[0], operands[2])))"
9168 +  [(set (match_dup 2)
9169 +       (mem:QI (plus:SI (reg:SI SP_REGNO)
9170 +                        (match_dup 4))))]
9171 +  "{
9172 +     operands[4] = GEN_INT (INTVAL (operands[1]) + 3);
9173 +   }")
9174 +
9175 --- /dev/null
9176 +++ b/gcc/config/ubicom32/ubicom32.opt
9177 @@ -0,0 +1,27 @@
9178 +mdebug-address
9179 +Target RejectNegative Report Undocumented Mask(DEBUG_ADDRESS)
9180 +Debug addresses
9181 +
9182 +mdebug-context
9183 +Target RejectNegative Report Undocumented Mask(DEBUG_CONTEXT)
9184 +Debug contexts
9185 +
9186 +march=
9187 +Target Report Var(ubicom32_arch_name) Init("ubicom32v4") Joined
9188 +Specify the name of the target architecture
9189 +
9190 +mfdpic
9191 +Target Report Mask(FDPIC)
9192 +Enable Function Descriptor PIC mode
9193 +
9194 +minline-plt
9195 +Target Report Mask(INLINE_PLT)
9196 +Enable inlining of PLT in function calls
9197 +
9198 +mfastcall
9199 +Target Report Mask(FASTCALL)
9200 +Enable default fast (call) calling sequence for smaller applications
9201 +
9202 +mipos-abi
9203 +Target Report Mask(IPOS_ABI)
9204 +Enable the ipOS ABI in which D10-D13 are caller-clobbered
9205 --- /dev/null
9206 +++ b/gcc/config/ubicom32/uclinux.h
9207 @@ -0,0 +1,67 @@
9208 +/* Definitions of target machine for Ubicom32-uclinux
9209 +
9210 +   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
9211 +   2009 Free Software Foundation, Inc.
9212 +   Contributed by Ubicom, Inc.
9213 +
9214 +   This file is part of GCC.
9215 +
9216 +   GCC is free software; you can redistribute it and/or modify it
9217 +   under the terms of the GNU General Public License as published
9218 +   by the Free Software Foundation; either version 3, or (at your
9219 +   option) any later version.
9220 +
9221 +   GCC is distributed in the hope that it will be useful, but WITHOUT
9222 +   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
9223 +   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
9224 +   License for more details.
9225 +
9226 +   You should have received a copy of the GNU General Public License
9227 +   along with GCC; see the file COPYING3.  If not see
9228 +   <http://www.gnu.org/licenses/>.  */
9229 +
9230 +/* Don't assume anything about the header files.  */
9231 +#define NO_IMPLICIT_EXTERN_C
9232 +
9233 +#undef  LIB_SPEC
9234 +#define LIB_SPEC  \
9235 +       "%{pthread:-lpthread} " \
9236 +       "%{!shared:%{!symbolic: -lc}} "
9237 +
9238 +
9239 +#undef LINK_GCC_C_SEQUENCE_SPEC
9240 +#define LINK_GCC_C_SEQUENCE_SPEC \
9241 +  "%{!shared:--start-group} %G %L %{!shared:--end-group}%{shared:%G} "
9242 +
9243 +#undef STARTFILE_SPEC
9244 +#define STARTFILE_SPEC \
9245 +       "%{!shared: crt1%O%s}" \
9246 +       " crti%O%s crtbegin%O%s"
9247 +
9248 +#undef ENDFILE_SPEC
9249 +#define ENDFILE_SPEC "crtend%O%s crtn%O%s"
9250 +
9251 +/* This macro applies on top of OBJECT_FORMAT_ELF and indicates that
9252 +   we want to support both flat and ELF output.  */
9253 +#define OBJECT_FORMAT_FLAT
9254 +
9255 +#undef DRIVER_SELF_SPECS
9256 +#define DRIVER_SELF_SPECS \
9257 +  "%{!mno-fastcall:-mfastcall}"
9258 +
9259 +/* taken from linux.h */
9260 +/* The GNU C++ standard library requires that these macros be defined.  */
9261 +#undef CPLUSPLUS_CPP_SPEC
9262 +#define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)"
9263 +
9264 +#define TARGET_OS_CPP_BUILTINS()                               \
9265 +    do {                                                       \
9266 +       builtin_define_std ("__UBICOM32__");                    \
9267 +       builtin_define_std ("__ubicom32__");                    \
9268 +       builtin_define ("__gnu_linux__");                       \
9269 +       builtin_define_std ("linux");                           \
9270 +       builtin_define_std ("unix");                            \
9271 +       builtin_assert ("system=linux");                        \
9272 +       builtin_assert ("system=unix");                         \
9273 +       builtin_assert ("system=posix");                        \
9274 +    } while (0)
9275 --- /dev/null
9276 +++ b/gcc/config/ubicom32/xm-ubicom32.h
9277 @@ -0,0 +1,36 @@
9278 +/* Configuration for Ubicom's Ubicom32 architecture.
9279 +   Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software
9280 +   Foundation, Inc.
9281 +   Contributed by Ubicom Inc.
9282 +
9283 +This file is part of GNU CC.
9284 +
9285 +GNU CC is free software; you can redistribute it and/or modify
9286 +it under the terms of the GNU General Public License as published by
9287 +the Free Software Foundation; either version 2, or (at your option)
9288 +any later version.
9289 +
9290 +GNU CC is distributed in the hope that it will be useful,
9291 +but WITHOUT ANY WARRANTY; without even the implied warranty of
9292 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
9293 +GNU General Public License for more details.
9294 +
9295 +You should have received a copy of the GNU General Public License
9296 +along with GNU CC; see the file COPYING.  If not, write to
9297 +the Free Software Foundation, 59 Temple Place - Suite 330,
9298 +Boston, MA 02111-1307, USA.  */
9299 +
9300 +/* #defines that need visibility everywhere.  */
9301 +#define FALSE 0
9302 +#define TRUE 1
9303 +
9304 +/* This describes the machine the compiler is hosted on.  */
9305 +#define HOST_BITS_PER_CHAR 8
9306 +#define HOST_BITS_PER_SHORT 16
9307 +#define HOST_BITS_PER_INT 32
9308 +#define HOST_BITS_PER_LONG 32
9309 +#define HOST_BITS_PER_LONGLONG 64
9310 +
9311 +/* Arguments to use with `exit'.  */
9312 +#define SUCCESS_EXIT_CODE 0
9313 +#define FATAL_EXIT_CODE 33
9314 --- a/gcc/config.gcc
9315 +++ b/gcc/config.gcc
9316 @@ -2314,6 +2314,34 @@ spu-*-elf*)
9317         c_target_objs="${c_target_objs} spu-c.o"
9318         cxx_target_objs="${cxx_target_objs} spu-c.o"
9319         ;;
9320 +ubicom32-*-elf)
9321 +       xm_file=ubicom32/xm-ubicom32.h
9322 +       tm_file="${tm_file} ubicom32/elf.h" # still need dbxelf.h elfos.h
9323 +       tmake_file=ubicom32/t-ubicom32
9324 +       ;;
9325 +ubicom32-*-uclinux*)
9326 +       xm_file=ubicom32/xm-ubicom32.h
9327 +       tm_file="${tm_file} ubicom32/elf.h ubicom32/uclinux.h"  # still need dbxelf.h elfos.h linux.h
9328 +       tm_defines="${tm_defines} UCLIBC_DEFAULT=1"
9329 +       extra_options="${extra_options} linux.opt"
9330 +       tmake_file=ubicom32/t-ubicom32-uclinux
9331 +       use_collect2=no
9332 +       ;;
9333 +ubicom32-*-linux-uclibc)
9334 +       xm_file=ubicom32/xm-ubicom32.h
9335 +       tm_file="${tm_file} ubicom32/elf.h linux.h ubicom32/linux.h"  # still need dbxelf.h elfos.h
9336 +       tmake_file="t-slibgcc-elf-ver ubicom32/t-ubicom32-linux"
9337 +       extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
9338 +       use_collect2=no
9339 +       ;;
9340 +ubicom32-*-linux*)
9341 +       xm_file=ubicom32/xm-ubicom32.h
9342 +       tm_file="${tm_file} ubicom32/elf.h linux.h ubicom32/linux.h"  # still need dbxelf.h elfos.h
9343 +       tmake_file="t-slibgcc-elf-ver ubicom32/t-ubicom32-linux"
9344 +       tm_defines="${tm_defines} UCLIBC_DEFAULT=1"
9345 +       extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
9346 +       use_collect2=no
9347 +       ;;
9348  v850e1-*-*)
9349         target_cpu_default="TARGET_CPU_v850e1"
9350         tm_file="dbxelf.h elfos.h svr4.h v850/v850.h"
9351 --- a/libgcc/config.host
9352 +++ b/libgcc/config.host
9353 @@ -551,6 +551,15 @@ sparc64-*-netbsd*)
9354         ;;
9355  spu-*-elf*)
9356         ;;
9357 +ubicom32*-*-elf*)
9358 +       ;;
9359 +ubicom32*-*-uclinux*)
9360 +        ;;
9361 +ubicom32*-*-linux*)
9362 +       # No need to build crtbeginT.o on uClibc systems.  Should probably
9363 +       # be moved to the OS specific section above.
9364 +       extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
9365 +        ;;
9366  v850e1-*-*)
9367         ;;
9368  v850e-*-*)