toolchain/gcc/patches/4.4.0/600-ubicom_support.patch

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