Root/toolchain/gcc/patches/4.4.3/600-ubicom_support.patch

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

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive