67fb7156066336dbc0a7795a1fba1cfcedc4ed08
[akaros.git] / tools / compilers / gcc-glibc / gcc-4.6.1-riscv.patch
1 diff --git a/gcc-4.6.1/config.sub b/gcc-4.6.1/config.sub
2 index 204218c..e14dc95 100755
3 --- a/gcc-4.6.1/config.sub
4 +++ gcc-4.6.1/config.sub
5 @@ -323,6 +323,9 @@ case $basic_machine in
6         ms1)
7                 basic_machine=mt-unknown
8                 ;;
9 +       riscv)
10 +               basic_machine=riscv-ucb
11 +               ;;
12  
13         # We use `pc' rather than `unknown'
14         # because (1) that's what they normally are, and
15 diff --git a/gcc-4.6.1/gcc/config.gcc b/gcc-4.6.1/gcc/config.gcc
16 index ada68dd..321d4f2 100644
17 --- a/gcc-4.6.1/gcc/config.gcc
18 +++ gcc-4.6.1/gcc/config.gcc
19 @@ -1861,6 +1861,18 @@ mips*-*-netbsd*)                 # NetBSD/mips, either endian.
20         tm_file="elfos.h ${tm_file} mips/elf.h netbsd.h netbsd-elf.h mips/netbsd.h"
21         extra_options="${extra_options} netbsd.opt netbsd-elf.opt"
22         ;;
23 +riscv*-*-linux*)                               # Linux RISC-V
24 +       tm_file="dbxelf.h elfos.h gnu-user.h linux.h glibc-stdint.h ${tm_file} riscv/linux.h riscv/linux64.h"
25 +       tmake_file="${tmake_file} riscv/t-linux64"
26 +       gnu_ld=yes
27 +       gas=yes
28 +       ;;
29 +riscv*-*-elf*)                         # Linux RISC-V
30 +       tm_file="dbxelf.h elfos.h newlib-stdint.h ${tm_file} riscv/elf.h"
31 +       tmake_file="${tmake_file} riscv/t-elf"
32 +       gnu_ld=yes
33 +       gas=yes
34 +       ;;
35  mips64*-*-linux* | mipsisa64*-*-linux*)
36         tm_file="dbxelf.h elfos.h gnu-user.h linux.h glibc-stdint.h ${tm_file} mips/linux.h mips/linux64.h"
37         tmake_file="${tmake_file} mips/t-linux64 mips/t-libgcc-mips16"
38 @@ -3381,6 +3393,31 @@ case "${target}" in
39                 done
40                 ;;
41  
42 +       riscv*-*-*)
43 +               supported_defaults="abi arch arch_32 arch_64 float tune tune_32 tune_64"
44 +
45 +               case ${with_float} in
46 +               "" | soft | hard)
47 +                       # OK
48 +                       ;;
49 +               *)
50 +                       echo "Unknown floating point type used in --with-float=$with_float" 1>&2
51 +                       exit 1
52 +                       ;;
53 +               esac
54 +
55 +               case ${with_abi} in
56 +               "" | 32 | 64)
57 +                       # OK
58 +                       ;;
59 +               *)
60 +                       echo "Unknown ABI used in --with-abi=$with_abi" 1>&2
61 +                       exit 1
62 +                       ;;
63 +               esac
64 +
65 +    ;;
66 +
67         mips*-*-*)
68                 supported_defaults="abi arch arch_32 arch_64 float tune tune_32 tune_64 divide llsc mips-plt synci"
69  
70 diff --git a/gcc-4.6.1/gcc/config/riscv/constraints.md b/gcc-4.6.1/gcc/config/riscv/constraints.md
71 new file mode 100644
72 index 0000000..f09a4bd
73 --- /dev/null
74 +++ gcc-4.6.1/gcc/config/riscv/constraints.md
75 @@ -0,0 +1,121 @@
76 +;; Constraint definitions for MIPS.
77 +;; Copyright (C) 2006, 2007, 2008, 2010 Free Software Foundation, Inc.
78 +;;
79 +;; This file is part of GCC.
80 +;;
81 +;; GCC is free software; you can redistribute it and/or modify
82 +;; it under the terms of the GNU General Public License as published by
83 +;; the Free Software Foundation; either version 3, or (at your option)
84 +;; any later version.
85 +;;
86 +;; GCC is distributed in the hope that it will be useful,
87 +;; but WITHOUT ANY WARRANTY; without even the implied warranty of
88 +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
89 +;; GNU General Public License for more details.
90 +;;
91 +;; You should have received a copy of the GNU General Public License
92 +;; along with GCC; see the file COPYING3.  If not see
93 +;; <http://www.gnu.org/licenses/>.
94 +
95 +;; Vector register constraints
96 +
97 +(define_register_constraint "A" "VEC_GR_REGS"
98 +  "A vector integer register.")
99 +
100 +(define_register_constraint "B" "VEC_FP_REGS"
101 +  "A vector floating-point register.")
102 +
103 +;; Register constraints
104 +
105 +(define_register_constraint "d" "GR_REGS"
106 +  "An address register.  This is equivalent to @code{r} unless
107 +   generating MIPS16 code.")
108 +
109 +(define_register_constraint "f" "TARGET_HARD_FLOAT ? FP_REGS : NO_REGS"
110 +  "A floating-point register (if available).")
111 +
112 +(define_register_constraint "h" "NO_REGS"
113 +  "Formerly the @code{hi} register.  This constraint is no longer supported.")
114 +
115 +(define_register_constraint "b" "ALL_REGS"
116 +  "@internal")
117 +
118 +(define_register_constraint "j" "V1_REG"
119 +  "@internal")
120 +
121 +(define_register_constraint "z" "GR_REGS"
122 +  "A floating-point condition code register.")
123 +
124 +;; This is a normal rather than a register constraint because we can
125 +;; never use the stack pointer as a reload register.
126 +(define_constraint "ks"
127 +  "@internal"
128 +  (and (match_code "reg")
129 +       (match_test "REGNO (op) == STACK_POINTER_REGNUM")))
130 +
131 +;; Integer constraints
132 +
133 +(define_constraint "Z"
134 +  "@internal"
135 +  (and (match_code "const_int")
136 +       (match_test "1")))
137 +
138 +(define_constraint "I"
139 +  "An I-type 12-bit signed immediate."
140 +  (and (match_code "const_int")
141 +       (match_test "SMALL_OPERAND (ival)")))
142 +
143 +(define_constraint "J"
144 +  "Integer zero."
145 +  (and (match_code "const_int")
146 +       (match_test "ival == 0")))
147 +
148 +;; Floating-point constraints
149 +
150 +(define_constraint "G"
151 +  "Floating-point zero."
152 +  (and (match_code "const_double")
153 +       (match_test "op == CONST0_RTX (mode)")))
154 +
155 +;; General constraints
156 +
157 +(define_constraint "Q"
158 +  "@internal"
159 +  (match_operand 0 "const_arith_operand"))
160 +
161 +(define_memory_constraint "YR"
162 +  "An address that is held in a general-purpose register."
163 +  (and (match_code "mem")
164 +       (match_test "GET_CODE(XEXP(op,0)) == REG")))
165 +
166 +(define_memory_constraint "R"
167 +  "An address that can be used in a non-macro load or store."
168 +  (and (match_code "mem")
169 +       (match_test "mips_address_insns (XEXP (op, 0), mode, false) == 1")))
170 +
171 +(define_constraint "S"
172 +  "@internal
173 +   A constant call address."
174 +  (and (match_operand 0 "call_insn_operand")
175 +       (match_test "CONSTANT_P (op)")))
176 +
177 +(define_constraint "T"
178 +  "@internal
179 +   A constant @code{move_operand}."
180 +  (and (match_operand 0 "move_operand")
181 +       (match_test "CONSTANT_P (op)")))
182 +
183 +(define_memory_constraint "W"
184 +  "@internal
185 +   A memory address based on a member of @code{BASE_REG_CLASS}.  This is
186 +   true for all references (although it can sometimes be implicit if
187 +   @samp{!TARGET_EXPLICIT_RELOCS}).  For MIPS16, it excludes stack and
188 +   constant-pool references."
189 +  (and (match_code "mem")
190 +       (match_operand 0 "memory_operand")))
191 +
192 +(define_constraint "YG"
193 +  "@internal
194 +   A vector zero."
195 +  (and (match_code "const_vector")
196 +       (match_test "op == CONST0_RTX (mode)")))
197 diff --git a/gcc-4.6.1/gcc/config/riscv/crti.asm b/gcc-4.6.1/gcc/config/riscv/crti.asm
198 new file mode 100644
199 index 0000000..ce9b393
200 --- /dev/null
201 +++ gcc-4.6.1/gcc/config/riscv/crti.asm
202 @@ -0,0 +1,42 @@
203 +/* Copyright (C) 2001, 2002 Free Software Foundation, Inc.
204 +
205 +This file is part of GCC.
206 +
207 +GCC is free software; you can redistribute it and/or modify it under
208 +the terms of the GNU General Public License as published by the Free
209 +Software Foundation; either version 3, or (at your option) any later
210 +version.
211 +
212 +GCC is distributed in the hope that it will be useful, but WITHOUT ANY
213 +WARRANTY; without even the implied warranty of MERCHANTABILITY or
214 +FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
215 +for more details.
216 +
217 +Under Section 7 of GPL version 3, you are granted additional
218 +permissions described in the GCC Runtime Library Exception, version
219 +3.1, as published by the Free Software Foundation.
220 +
221 +You should have received a copy of the GNU General Public License and
222 +a copy of the GCC Runtime Library Exception along with this program;
223 +see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
224 +<http://www.gnu.org/licenses/>.  */
225 +
226 +#ifdef __riscv64
227 +# define SR sd
228 +#else
229 +# define SR sw
230 +#endif
231 +
232 +       .section .init,"ax",@progbits
233 +       .globl  _init
234 +       .type   _init,@function
235 +_init:
236 +       add     sp, sp, -8
237 +       SR      ra, 0(sp)
238 +
239 +       .section .fini,"ax",@progbits
240 +       .globl  _fini
241 +       .type   _fini,@function
242 +_fini:
243 +       add     sp, sp, -8
244 +       SR      ra, 0(sp)
245 diff --git a/gcc-4.6.1/gcc/config/riscv/crtn.asm b/gcc-4.6.1/gcc/config/riscv/crtn.asm
246 new file mode 100644
247 index 0000000..2b82d24
248 --- /dev/null
249 +++ gcc-4.6.1/gcc/config/riscv/crtn.asm
250 @@ -0,0 +1,38 @@
251 +/* Copyright (C) 2001, 2002 Free Software Foundation, Inc.
252 +
253 +This file is part of GCC.
254 +
255 +GCC is free software; you can redistribute it and/or modify it under
256 +the terms of the GNU General Public License as published by the Free
257 +Software Foundation; either version 3, or (at your option) any later
258 +version.
259 +
260 +GCC is distributed in the hope that it will be useful, but WITHOUT ANY
261 +WARraNTY; without even the implied warranty of MERCHANTABILITY or
262 +FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
263 +for more details.
264 +
265 +Under Section 7 of GPL version 3, you are granted additional
266 +permissions described in the GCC Runtime Library Exception, version
267 +3.1, as published by the Free Software Foundation.
268 +
269 +You should have received a copy of the GNU General Public License and
270 +a copy of the GCC Runtime Library Exception along with this program;
271 +see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
272 +<http://www.gnu.org/licenses/>.  */
273 +
274 +#ifdef __riscv64
275 +# define LR ld
276 +#else
277 +# define LR lw
278 +#endif
279 +
280 +       .section .init,"ax",@progbits
281 +       LR      ra, 0(sp)
282 +       addi    sp, sp, 8
283 +       ret
284 +
285 +       .section .fini,"ax",@progbits
286 +       LR      ra, 0(sp)
287 +       addi    sp, sp, 8
288 +       ret
289 diff --git a/gcc-4.6.1/gcc/config/riscv/elf.h b/gcc-4.6.1/gcc/config/riscv/elf.h
290 new file mode 100644
291 index 0000000..5725537
292 --- /dev/null
293 +++ gcc-4.6.1/gcc/config/riscv/elf.h
294 @@ -0,0 +1,51 @@
295 +/* Target macros for mips*-elf targets.
296 +   Copyright (C) 1994, 1997, 1999, 2000, 2002, 2003, 2004, 2007, 2010
297 +   Free Software Foundation, Inc.
298 +
299 +This file is part of GCC.
300 +
301 +GCC is free software; you can redistribute it and/or modify
302 +it under the terms of the GNU General Public License as published by
303 +the Free Software Foundation; either version 3, or (at your option)
304 +any later version.
305 +
306 +GCC is distributed in the hope that it will be useful,
307 +but WITHOUT ANY WARRANTY; without even the implied warranty of
308 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
309 +GNU General Public License for more details.
310 +
311 +You should have received a copy of the GNU General Public License
312 +along with GCC; see the file COPYING3.  If not see
313 +<http://www.gnu.org/licenses/>.  */
314 +
315 +/* MIPS assemblers don't have the usual .set foo,bar construct;
316 +   .set is used for assembler options instead.  */
317 +#undef SET_ASM_OP
318 +#define ASM_OUTPUT_DEF(FILE, LABEL1, LABEL2)                   \
319 +  do                                                           \
320 +    {                                                          \
321 +      fputc ('\t', FILE);                                      \
322 +      assemble_name (FILE, LABEL1);                            \
323 +      fputs (" = ", FILE);                                     \
324 +      assemble_name (FILE, LABEL2);                            \
325 +      fputc ('\n', FILE);                                      \
326 +    }                                                          \
327 +  while (0)
328 +
329 +#undef ASM_DECLARE_OBJECT_NAME
330 +#define ASM_DECLARE_OBJECT_NAME mips_declare_object_name
331 +
332 +#undef ASM_FINISH_DECLARE_OBJECT
333 +#define ASM_FINISH_DECLARE_OBJECT mips_finish_declare_object
334 +
335 +/* Leave the linker script to choose the appropriate libraries.  */
336 +#undef  LIB_SPEC
337 +#define LIB_SPEC ""
338 +
339 +#undef  STARTFILE_SPEC
340 +#define STARTFILE_SPEC "crti%O%s crtbegin%O%s"
341 +
342 +#undef  ENDFILE_SPEC
343 +#define ENDFILE_SPEC "crtend%O%s crtn%O%s"
344 +
345 +#define NO_IMPLICIT_EXTERN_C 1
346 diff --git a/gcc-4.6.1/gcc/config/riscv/generic.md b/gcc-4.6.1/gcc/config/riscv/generic.md
347 new file mode 100644
348 index 0000000..d61511f
349 --- /dev/null
350 +++ gcc-4.6.1/gcc/config/riscv/generic.md
351 @@ -0,0 +1,105 @@
352 +;; Generic DFA-based pipeline description for MIPS targets
353 +;;   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
354 +;;
355 +;; This file is part of GCC.
356 +
357 +;; GCC is free software; you can redistribute it and/or modify it
358 +;; under the terms of the GNU General Public License as published
359 +;; by the Free Software Foundation; either version 3, or (at your
360 +;; option) any later version.
361 +
362 +;; GCC is distributed in the hope that it will be useful, but WITHOUT
363 +;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
364 +;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
365 +;; License for more details.
366 +
367 +;; You should have received a copy of the GNU General Public License
368 +;; along with GCC; see the file COPYING3.  If not see
369 +;; <http://www.gnu.org/licenses/>.
370 +
371 +
372 +;; This file is derived from the old define_function_unit description.
373 +;; Each reservation can be overridden on a processor-by-processor basis.
374 +
375 +(define_insn_reservation "generic_alu" 1
376 +  (eq_attr "type" "unknown,prefetch,prefetchx,condmove,const,arith,
377 +                  shift,slt,clz,trap,multi,nop,logical,signext,move")
378 +  "alu")
379 +
380 +(define_insn_reservation "generic_load" 3
381 +  (eq_attr "type" "load,fpload,fpidxload")
382 +  "alu")
383 +
384 +(define_insn_reservation "generic_store" 1
385 +  (eq_attr "type" "store,fpstore,fpidxstore")
386 +  "alu")
387 +
388 +(define_insn_reservation "generic_xfer" 2
389 +  (eq_attr "type" "mfc,mtc")
390 +  "alu")
391 +
392 +(define_insn_reservation "generic_branch" 1
393 +  (eq_attr "type" "branch,jump,call")
394 +  "alu")
395 +
396 +(define_insn_reservation "generic_hilo" 1
397 +  (eq_attr "type" "mfhilo,mthilo")
398 +  "imuldiv*3")
399 +
400 +(define_insn_reservation "generic_imul" 17
401 +  (eq_attr "type" "imul,imul3,imadd")
402 +  "imuldiv*17")
403 +
404 +(define_insn_reservation "generic_idiv" 38
405 +  (eq_attr "type" "idiv")
406 +  "imuldiv*38")
407 +
408 +(define_insn_reservation "generic_fcvt" 1
409 +  (eq_attr "type" "fcvt")
410 +  "alu")
411 +
412 +(define_insn_reservation "generic_fmove" 2
413 +  (eq_attr "type" "fabs,fneg,fmove")
414 +  "alu")
415 +
416 +(define_insn_reservation "generic_fcmp" 3
417 +  (eq_attr "type" "fcmp")
418 +  "alu")
419 +
420 +(define_insn_reservation "generic_fadd" 4
421 +  (eq_attr "type" "fadd")
422 +  "alu")
423 +
424 +(define_insn_reservation "generic_fmul_single" 7
425 +  (and (eq_attr "type" "fmul,fmadd")
426 +       (eq_attr "mode" "SF"))
427 +  "alu")
428 +
429 +(define_insn_reservation "generic_fmul_double" 8
430 +  (and (eq_attr "type" "fmul,fmadd")
431 +       (eq_attr "mode" "DF"))
432 +  "alu")
433 +
434 +(define_insn_reservation "generic_fdiv_single" 23
435 +  (and (eq_attr "type" "fdiv,frdiv")
436 +       (eq_attr "mode" "SF"))
437 +  "alu")
438 +
439 +(define_insn_reservation "generic_fdiv_double" 36
440 +  (and (eq_attr "type" "fdiv,frdiv")
441 +       (eq_attr "mode" "DF"))
442 +  "alu")
443 +
444 +(define_insn_reservation "generic_fsqrt_single" 54
445 +  (and (eq_attr "type" "fsqrt,frsqrt")
446 +       (eq_attr "mode" "SF"))
447 +  "alu")
448 +
449 +(define_insn_reservation "generic_fsqrt_double" 112
450 +  (and (eq_attr "type" "fsqrt,frsqrt")
451 +       (eq_attr "mode" "DF"))
452 +  "alu")
453 +
454 +(define_insn_reservation "generic_frecip_fsqrt_step" 5
455 +  (eq_attr "type" "frdiv1,frdiv2,frsqrt1,frsqrt2")
456 +  "alu")
457 diff --git a/gcc-4.6.1/gcc/config/riscv/linux-unwind.h b/gcc-4.6.1/gcc/config/riscv/linux-unwind.h
458 new file mode 100644
459 index 0000000..02f7cd5
460 --- /dev/null
461 +++ gcc-4.6.1/gcc/config/riscv/linux-unwind.h
462 @@ -0,0 +1,120 @@
463 +/* DWARF2 EH unwinding support for MIPS Linux.
464 +   Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
465 +
466 +This file is part of GCC.
467 +
468 +GCC is free software; you can redistribute it and/or modify
469 +it under the terms of the GNU General Public License as published by
470 +the Free Software Foundation; either version 3, or (at your option)
471 +any later version.
472 +
473 +GCC is distributed in the hope that it will be useful,
474 +but WITHOUT ANY WARRANTY; without even the implied warranty of
475 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
476 +GNU General Public License for more details.
477 +
478 +Under Section 7 of GPL version 3, you are granted additional
479 +permissions described in the GCC Runtime Library Exception, version
480 +3.1, as published by the Free Software Foundation.
481 +
482 +You should have received a copy of the GNU General Public License and
483 +a copy of the GCC Runtime Library Exception along with this program;
484 +see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
485 +<http://www.gnu.org/licenses/>.  */
486 +
487 +#ifndef inhibit_libc
488 +/* Do code reading to identify a signal frame, and set the frame
489 +   state data appropriately.  See unwind-dw2.c for the structs.  */
490 +
491 +#include <signal.h>
492 +#include <asm/unistd.h>
493 +
494 +/* The third parameter to the signal handler points to something with
495 + * this structure defined in asm/ucontext.h, but the name clashes with
496 + * struct ucontext from sys/ucontext.h so this private copy is used.  */
497 +typedef struct _sig_ucontext {
498 +    unsigned long         uc_flags;
499 +    struct _sig_ucontext  *uc_link;
500 +    stack_t               uc_stack;
501 +    struct sigcontext uc_mcontext;
502 +    sigset_t      uc_sigmask;
503 +} _sig_ucontext_t;
504 +
505 +#define MD_FALLBACK_FRAME_STATE_FOR mips_fallback_frame_state
506 +
507 +static _Unwind_Reason_Code
508 +mips_fallback_frame_state (struct _Unwind_Context *context,
509 +                          _Unwind_FrameState *fs)
510 +{
511 +  u_int32_t *pc = (u_int32_t *) context->ra;
512 +  struct sigcontext *sc;
513 +  _Unwind_Ptr new_cfa, reg_offset;
514 +  int i;
515 +
516 +  /* 24021061 li v0, 0x1061 (rt_sigreturn)*/
517 +  /* 0000000c syscall    */
518 +  /*    or */
519 +  /* 24021017 li v0, 0x1017 (sigreturn) */
520 +  /* 0000000c syscall  */
521 +  if (pc[1] != 0x0000000c)
522 +    return _URC_END_OF_STACK;
523 +#if _MIPS_SIM == _ABIO32
524 +  if (pc[0] == (0x24020000 | __NR_sigreturn))
525 +    {
526 +      struct sigframe {
527 +       u_int32_t ass[4];  /* Argument save space for o32.  */
528 +       u_int32_t trampoline[2];
529 +       struct sigcontext sigctx;
530 +      } *rt_ = context->cfa;
531 +      sc = &rt_->sigctx;
532 +    }
533 +  else
534 +#endif
535 +  if (pc[0] == (0x24020000 | __NR_rt_sigreturn))
536 +    {
537 +      struct rt_sigframe {
538 +       u_int32_t ass[4];  /* Argument save space for o32.  */
539 +       u_int32_t trampoline[2];
540 +       struct siginfo info;
541 +       _sig_ucontext_t uc;
542 +      } *rt_ = context->cfa;
543 +      sc = &rt_->uc.uc_mcontext;
544 +    }
545 +  else
546 +    return _URC_END_OF_STACK;
547 +
548 +  new_cfa = (_Unwind_Ptr) sc;
549 +  fs->regs.cfa_how = CFA_REG_OFFSET;
550 +  fs->regs.cfa_reg = STACK_POINTER_REGNUM;
551 +  fs->regs.cfa_offset = new_cfa - (_Unwind_Ptr) context->cfa;
552 +
553 +  /* On o32 Linux, the register save slots in the sigcontext are
554 +     eight bytes.  We need the lower half of each register slot,
555 +     so slide our view of the structure back four bytes.  */
556 +#if _MIPS_SIM == _ABIO32 && defined __MIPSEB__
557 +  reg_offset = 4;
558 +#else
559 +  reg_offset = 0;
560 +#endif
561 +
562 +  for (i = 0; i < 32; i++) {
563 +    fs->regs.reg[i].how = REG_SAVED_OFFSET;
564 +    fs->regs.reg[i].loc.offset
565 +      = (_Unwind_Ptr)&(sc->sc_regs[i]) + reg_offset - new_cfa;
566 +  }
567 +  /* "PC & -2" points to the faulting instruction, but the unwind code
568 +     searches for "(ADDR & -2) - 1".  (See MASK_RETURN_ADDR for the source
569 +     of the -2 mask.)  Adding 2 here ensures that "(ADDR & -2) - 1" is the
570 +     address of the second byte of the faulting instruction.
571 +
572 +     Note that setting fs->signal_frame would not work.  As the comment
573 +     above MASK_RETURN_ADDR explains, MIPS unwinders must earch for an
574 +     odd-valued address.  */
575 +  fs->regs.reg[DWARF_ALT_FRAME_RETURN_COLUMN].how = REG_SAVED_VAL_OFFSET;
576 +  fs->regs.reg[DWARF_ALT_FRAME_RETURN_COLUMN].loc.offset
577 +    = (_Unwind_Ptr)(sc->sc_pc) + 2 - new_cfa;
578 +  fs->retaddr_column = DWARF_ALT_FRAME_RETURN_COLUMN;
579 +
580 +  return _URC_NO_REASON;
581 +}
582 +#endif
583 diff --git a/gcc-4.6.1/gcc/config/riscv/linux.h b/gcc-4.6.1/gcc/config/riscv/linux.h
584 new file mode 100644
585 index 0000000..25fb105
586 --- /dev/null
587 +++ gcc-4.6.1/gcc/config/riscv/linux.h
588 @@ -0,0 +1,115 @@
589 +/* Definitions for MIPS running Linux-based GNU systems with ELF format.
590 +   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
591 +   2007, 2008, 2010, 2011 Free Software Foundation, Inc.
592 +
593 +This file is part of GCC.
594 +
595 +GCC is free software; you can redistribute it and/or modify
596 +it under the terms of the GNU General Public License as published by
597 +the Free Software Foundation; either version 3, or (at your option)
598 +any later version.
599 +
600 +GCC is distributed in the hope that it will be useful,
601 +but WITHOUT ANY WARRANTY; without even the implied warranty of
602 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
603 +GNU General Public License for more details.
604 +
605 +You should have received a copy of the GNU General Public License
606 +along with GCC; see the file COPYING3.  If not see
607 +<http://www.gnu.org/licenses/>.  */
608 +
609 +#undef WCHAR_TYPE
610 +#define WCHAR_TYPE "int"
611 +
612 +#undef WCHAR_TYPE_SIZE
613 +#define WCHAR_TYPE_SIZE 32
614 +
615 +#undef ASM_DECLARE_OBJECT_NAME
616 +#define ASM_DECLARE_OBJECT_NAME mips_declare_object_name
617 +
618 +#undef TARGET_VERSION
619 +#if TARGET_ENDIAN_DEFAULT == 0
620 +#define TARGET_VERSION fprintf (stderr, " (RISC-V LE Linux/ELF)");
621 +#else
622 +#define TARGET_VERSION fprintf (stderr, " (RISC-V BE Linux/ELF)");
623 +#endif
624 +
625 +/* If we don't set MASK_ABICALLS, we can't default to PIC.  */
626 +#undef TARGET_DEFAULT
627 +#define TARGET_DEFAULT MASK_ABICALLS
628 +
629 +#define TARGET_OS_CPP_BUILTINS()                               \
630 +  do {                                                         \
631 +    LINUX_TARGET_OS_CPP_BUILTINS();                            \
632 +    /* The GNU C++ standard library requires this.  */         \
633 +    if (c_dialect_cxx ())                                      \
634 +      builtin_define ("_GNU_SOURCE");                          \
635 +  } while (0)
636 +
637 +#undef SUBTARGET_CPP_SPEC
638 +#define SUBTARGET_CPP_SPEC "%{posix:-D_POSIX_SOURCE} %{pthread:-D_REENTRANT}"
639 +
640 +/* A standard GNU/Linux mapping.  On most targets, it is included in
641 +   CC1_SPEC itself by config/linux.h, but mips.h overrides CC1_SPEC
642 +   and provides this hook instead.  */
643 +#undef SUBTARGET_CC1_SPEC
644 +#define SUBTARGET_CC1_SPEC "%{profile:-p}"
645 +
646 +#define GLIBC_DYNAMIC_LINKER "/lib/ld.so.1"
647 +
648 +/* Borrowed from sparc/linux.h */
649 +#undef LINK_SPEC
650 +#define LINK_SPEC \
651 + "%(endian_spec) \
652 +  %{shared:-shared} \
653 +  %{!shared: \
654 +    %{!static: \
655 +      %{rdynamic:-export-dynamic} \
656 +      -dynamic-linker " LINUX_DYNAMIC_LINKER "} \
657 +      %{static:-static}}"
658 +
659 +/* The MIPS assembler has different syntax for .set. We set it to
660 +   .dummy to trap any errors.  */
661 +#undef SET_ASM_OP
662 +#define SET_ASM_OP "\t.dummy\t"
663 +
664 +#undef ASM_OUTPUT_DEF
665 +#define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)                             \
666 + do {                                                                  \
667 +       fputc ( '\t', FILE);                                            \
668 +       assemble_name (FILE, LABEL1);                                   \
669 +       fputs ( " = ", FILE);                                           \
670 +       assemble_name (FILE, LABEL2);                                   \
671 +       fputc ( '\n', FILE);                                            \
672 + } while (0)
673 +
674 +/* The glibc _mcount stub will save $v0 for us.  Don't mess with saving
675 +   it, since ASM_OUTPUT_REG_PUSH/ASM_OUTPUT_REG_POP do not work in the
676 +   presence of $gp-relative calls.  */
677 +#undef ASM_OUTPUT_REG_PUSH
678 +#undef ASM_OUTPUT_REG_POP
679 +
680 +#undef LIB_SPEC
681 +#define LIB_SPEC "\
682 +%{pthread:-lpthread} \
683 +%{shared:-lc} \
684 +%{!shared: \
685 +  %{profile:-lc_p} %{!profile:-lc}}"
686 +
687 +#define MD_UNWIND_SUPPORT "config/riscv/linux-unwind.h"
688 +
689 +/* -march=native handling only makes sense with compiler running on
690 +   a RISC-V machine.  */
691 +#define MARCH_MTUNE_NATIVE_SPECS ""
692 +
693 +#define LINUX_DRIVER_SELF_SPECS \
694 +  MARCH_MTUNE_NATIVE_SPECS
695 +
696 +#undef DRIVER_SELF_SPECS
697 +#define DRIVER_SELF_SPECS \
698 +  LINUX_DRIVER_SELF_SPECS
699 +
700 +/* Similar to standard Linux, but adding -ffast-math support.  */
701 +#undef  ENDFILE_SPEC
702 +#define ENDFILE_SPEC \
703 +   "%{shared|pie:crtendS.o%s;:crtend.o%s} crtn.o%s"
704 diff --git a/gcc-4.6.1/gcc/config/riscv/linux64.h b/gcc-4.6.1/gcc/config/riscv/linux64.h
705 new file mode 100644
706 index 0000000..c742cf1
707 --- /dev/null
708 +++ gcc-4.6.1/gcc/config/riscv/linux64.h
709 @@ -0,0 +1,58 @@
710 +/* Definitions for MIPS running Linux-based GNU systems with ELF format
711 +   using n32/64 abi.
712 +   Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011
713 +   Free Software Foundation, Inc.
714 +
715 +This file is part of GCC.
716 +
717 +GCC is free software; you can redistribute it and/or modify
718 +it under the terms of the GNU General Public License as published by
719 +the Free Software Foundation; either version 3, or (at your option)
720 +any later version.
721 +
722 +GCC is distributed in the hope that it will be useful,
723 +but WITHOUT ANY WARRANTY; without even the implied warranty of
724 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
725 +GNU General Public License for more details.
726 +
727 +You should have received a copy of the GNU General Public License
728 +along with GCC; see the file COPYING3.  If not see
729 +<http://www.gnu.org/licenses/>.  */
730 +
731 +/* Force the default endianness and ABI flags onto the command line
732 +   in order to make the other specs easier to write.  */
733 +#undef DRIVER_SELF_SPECS
734 +#define DRIVER_SELF_SPECS \
735 +  LINUX_DRIVER_SELF_SPECS \
736 +  " %{!EB:%{!EL:%(endian_spec)}}" \
737 +  " %{" OPT_ARCH32 ": -m32} %{" OPT_ARCH64 ": -m64}" \
738 +
739 +#undef LIB_SPEC
740 +#define LIB_SPEC "\
741 +%{pthread:-lpthread} \
742 +%{shared:-lc} \
743 +%{!shared: \
744 +  %{profile:-lc_p} %{!profile:-lc}}"
745 +
746 +#define GLIBC_DYNAMIC_LINKER32 "/lib32/ld.so.1"
747 +#define GLIBC_DYNAMIC_LINKER64 "/lib/ld.so.1"
748 +
749 +#undef LINK_SPEC
750 +#define LINK_SPEC "\
751 +%{G*} %{EB} %{EL} %{mips1} %{mips2} %{mips3} %{mips4} \
752 +%{shared} \
753 + %(endian_spec) \
754 +  %{!shared: \
755 +    %{!static: \
756 +      %{rdynamic:-export-dynamic} \
757 +      %{" OPT_ARCH64 ": -dynamic-linker " LINUX_DYNAMIC_LINKER64 "} \
758 +      %{" OPT_ARCH32 ": -dynamic-linker " LINUX_DYNAMIC_LINKER32 "}} \
759 +    %{static:-static}} \
760 +%{" OPT_ARCH64 ":-melf64%{EB:b}%{EL:l}riscv} \
761 +%{" OPT_ARCH32 ":-melf32%{EB:b}%{EL:l}riscv}"
762 +
763 +/* GNU/Linux doesn't use the same floating-point format that IRIX uses
764 +   for long double.  There's no need to override this here, since
765 +   ieee_quad_format is the default, but let's put this here to make
766 +   sure nobody thinks we just forgot to set it to something else.  */
767 +#define MIPS_TFMODE_FORMAT mips_quad_format
768 diff --git a/gcc-4.6.1/gcc/config/riscv/opcode-riscv.h b/gcc-4.6.1/gcc/config/riscv/opcode-riscv.h
769 new file mode 100644
770 index 0000000..2a3d835
771 --- /dev/null
772 +++ gcc-4.6.1/gcc/config/riscv/opcode-riscv.h
773 @@ -0,0 +1,253 @@
774 +/* riscv.h.  RISC-V opcode list for GDB, the GNU debugger.
775 +   Copyright 2011
776 +   Free Software Foundation, Inc.
777 +   Contributed by Andrew Waterman 
778 +
779 +This file is part of GDB, GAS, and the GNU binutils.
780 +
781 +GDB, GAS, and the GNU binutils are free software; you can redistribute
782 +them and/or modify them under the terms of the GNU General Public
783 +License as published by the Free Software Foundation; either version
784 +1, or (at your option) any later version.
785 +
786 +GDB, GAS, and the GNU binutils are distributed in the hope that they
787 +will be useful, but WITHOUT ANY WARRANTY; without even the implied
788 +warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
789 +the GNU General Public License for more details.
790 +
791 +You should have received a copy of the GNU General Public License
792 +along with this file; see the file COPYING.  If not, write to the Free
793 +Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
794 +
795 +#ifndef _RISCV_H_
796 +#define _RISCV_H_
797 +
798 +/* RVC fields */
799 +
800 +#define OP_MASK_COP            0x1f
801 +#define OP_SH_COP              0
802 +#define OP_MASK_CRD            0x1f
803 +#define OP_SH_CRD              5
804 +#define OP_MASK_CRS2   0x1f
805 +#define OP_SH_CRS2     5
806 +#define OP_MASK_CRS1   0x1f
807 +#define OP_SH_CRS1     10
808 +#define OP_MASK_CRDS           0x7
809 +#define OP_SH_CRDS             13
810 +#define OP_MASK_CRS2S  0x7
811 +#define OP_SH_CRS2S    13
812 +#define OP_MASK_CRS2BS 0x7
813 +#define OP_SH_CRS2BS   5
814 +#define OP_MASK_CRS1S  0x7
815 +#define OP_SH_CRS1S    10
816 +#define OP_MASK_CIMM6  0x3f
817 +#define OP_SH_CIMM6    10
818 +#define OP_MASK_CIMM5  0x1f
819 +#define OP_SH_CIMM5    5
820 +#define OP_MASK_CIMM10 0x3ff
821 +#define OP_SH_CIMM10   5
822 +
823 +static const char rvc_rs1_regmap[8] = { 20, 21, 2, 3, 4, 5, 6, 7 };
824 +#define rvc_rd_regmap rvc_rs1_regmap
825 +#define rvc_rs2b_regmap rvc_rs1_regmap
826 +static const char rvc_rs2_regmap[8] = { 20, 21, 2, 3, 4, 5, 6, 0 };
827 +
828 +#define RVC_JUMP_BITS 10
829 +#define RVC_JUMP_ALIGN_BITS 1
830 +#define RVC_JUMP_ALIGN (1 << RVC_JUMP_ALIGN_BITS)
831 +#define RVC_JUMP_REACH ((1ULL<<RVC_JUMP_BITS)*RVC_JUMP_ALIGN)
832 +
833 +#define RVC_BRANCH_BITS 5
834 +#define RVC_BRANCH_ALIGN_BITS RVC_JUMP_ALIGN_BITS
835 +#define RVC_BRANCH_ALIGN (1 << RVC_BRANCH_ALIGN_BITS)
836 +#define RVC_BRANCH_REACH ((1ULL<<RVC_BRANCH_BITS)*RVC_BRANCH_ALIGN)
837 +
838 +#define RISCV_JTYPE(insn, target) \
839 +  ((MATCH_ ## insn) | (((target) & ((1<<RISCV_JUMP_BITS)-1)) << OP_SH_TARGET))
840 +#define RISCV_LTYPE(insn, rd, bigimm) \
841 +  ((MATCH_ ## insn) | ((rd) << OP_SH_RD) | (((bigimm) & ((1<<RISCV_BIGIMM_BITS)-1)) << OP_SH_BIGIMMEDIATE))
842 +#define RISCV_ITYPE(insn, rd, rs1, imm) \
843 +  ((MATCH_ ## insn) | ((rd) << OP_SH_RD) | ((rs1) << OP_SH_RS) | (((imm) & (RISCV_IMM_REACH-1)) << OP_SH_IMMEDIATE))
844 +#define RISCV_RTYPE(insn, rd, rs1, rs2) \
845 +  ((MATCH_ ## insn) | ((rd) << OP_SH_RD) | ((rs1) << OP_SH_RS) | ((rs2) << OP_SH_RT))
846 +
847 +#define RISCV_NOP RISCV_ITYPE(ADDI, 0, 0, 0)
848 +
849 +#define RISCV_JUMP_TARGET(address) ((address) >> RISCV_JUMP_ALIGN_BITS)
850 +#define RISCV_CONST_HIGH_PART(VALUE) \
851 +  (((VALUE) + (RISCV_IMM_REACH/2)) & ~(RISCV_IMM_REACH-1))
852 +#define RISCV_CONST_LOW_PART(VALUE) ((VALUE) - RISCV_CONST_HIGH_PART (VALUE))
853 +#define RISCV_LUI_HIGH_PART(VALUE) (RISCV_CONST_HIGH_PART(VALUE) >> RISCV_IMM_BITS)
854 +
855 +/* RV fields */
856 +
857 +#define OP_MASK_OP             0x7f
858 +#define OP_SH_OP               0
859 +#define OP_MASK_RT             0x1f
860 +#define OP_SH_RT               17
861 +#define OP_MASK_FT             0x1f
862 +#define OP_SH_FT               17
863 +#define OP_MASK_RS             0x1f
864 +#define OP_SH_RS               22
865 +#define OP_MASK_FS             0x1f
866 +#define OP_SH_FS               22
867 +#define OP_MASK_FR             0x1f
868 +#define OP_SH_FR               12
869 +#define OP_MASK_RD             0x1f
870 +#define OP_SH_RD               27
871 +#define OP_MASK_FD             0x1f
872 +#define OP_SH_FD               27
873 +#define OP_MASK_SHAMT          0x3f
874 +#define OP_SH_SHAMT            10
875 +#define OP_MASK_SHAMTW         0x1f
876 +#define OP_SH_SHAMTW   10
877 +#define OP_MASK_RM             0x7
878 +#define OP_SH_RM       9
879 +
880 +static const char * const riscv_rm[8] =
881 +  { "rne", "rtz", "rdn", "rup", "rmm", 0, 0, "dyn" };
882 +
883 +#define OP_MASK_VRD            0x1f
884 +#define OP_SH_VRD              27
885 +#define OP_MASK_VRS            0x1f
886 +#define OP_SH_VRS              22
887 +#define OP_MASK_VRT            0x1f
888 +#define OP_SH_VRT              17
889 +#define OP_MASK_VRR            0x1f
890 +#define OP_SH_VRR              12
891 +
892 +#define OP_MASK_VFD            0x1f
893 +#define OP_SH_VFD              27
894 +#define OP_MASK_VFS            0x1f
895 +#define OP_SH_VFS              22
896 +#define OP_MASK_VFT            0x1f
897 +#define OP_SH_VFT              17
898 +#define OP_MASK_VFR            0x1f
899 +#define OP_SH_VFR              12
900 +
901 +#define OP_MASK_IMMNGPR         0x3f
902 +#define OP_SH_IMMNGPR           10
903 +#define OP_MASK_IMMNFPR         0x3f
904 +#define OP_SH_IMMNFPR           16
905 +#define OP_MASK_IMMSEGNELM      0x1f
906 +#define OP_SH_IMMSEGNELM        17
907 +#define OP_MASK_IMMSEGSTNELM    0x1f
908 +#define OP_SH_IMMSEGSTNELM      12
909 +
910 +#define LINK_REG 1
911 +
912 +#define RISCV_JUMP_BITS 25
913 +#define RISCV_JUMP_ALIGN_BITS 1
914 +#define RISCV_JUMP_ALIGN (1 << RISCV_JUMP_ALIGN_BITS)
915 +#define RISCV_JUMP_REACH ((1ULL<<RISCV_JUMP_BITS)*RISCV_JUMP_ALIGN)
916 +
917 +#define OP_MASK_TARGET         ((1<<RISCV_JUMP_BITS)-1)
918 +#define OP_SH_TARGET           7
919 +
920 +#define RISCV_IMM_BITS 12
921 +#define RISCV_IMMLO_BITS 7
922 +#define RISCV_IMMHI_BITS (RISCV_IMM_BITS - RISCV_IMMLO_BITS)
923 +#define RISCV_BIGIMM_BITS (32-RISCV_IMM_BITS)
924 +#define RISCV_IMM_REACH (1LL<<RISCV_IMM_BITS)
925 +#define RISCV_BIGIMM_REACH (1LL<<RISCV_BIGIMM_BITS)
926 +#define RISCV_BRANCH_BITS RISCV_IMM_BITS
927 +#define RISCV_BRANCH_ALIGN_BITS RISCV_JUMP_ALIGN_BITS
928 +#define RISCV_BRANCH_ALIGN (1 << RISCV_BRANCH_ALIGN_BITS)
929 +#define RISCV_BRANCH_REACH (RISCV_IMM_REACH*RISCV_BRANCH_ALIGN)
930 +
931 +#define OP_MASK_BIGIMMEDIATE   ((1<<RISCV_BIGIMM_BITS)-1)
932 +#define OP_SH_BIGIMMEDIATE             7
933 +#define OP_MASK_IMMEDIATE      ((1<<RISCV_IMM_BITS)-1)
934 +#define OP_SH_IMMEDIATE                10
935 +#define OP_MASK_IMMLO ((1<<RISCV_IMMLO_BITS)-1)
936 +#define OP_SH_IMMLO   10
937 +#define OP_MASK_IMMHI ((1<<(RISCV_IMM_BITS-RISCV_IMMLO_BITS))-1)
938 +#define OP_SH_IMMHI   27
939 +
940 +#include "riscv-opc.h"
941 +
942 +/* This structure holds information for a particular instruction.  */
943 +
944 +struct riscv_opcode
945 +{
946 +  /* The name of the instruction.  */
947 +  const char *name;
948 +  /* A string describing the arguments for this instruction.  */
949 +  const char *args;
950 +  /* The basic opcode for the instruction.  When assembling, this
951 +     opcode is modified by the arguments to produce the actual opcode
952 +     that is used.  If pinfo is INSN_MACRO, then this is 0.  */
953 +  unsigned long match;
954 +  /* If pinfo is not INSN_MACRO, then this is a bit mask for the
955 +     relevant portions of the opcode when disassembling.  If the
956 +     actual opcode anded with the match field equals the opcode field,
957 +     then we have found the correct instruction.  If pinfo is
958 +     INSN_MACRO, then this field is the macro identifier.  */
959 +  unsigned long mask;
960 +  /* For a macro, this is INSN_MACRO.  Otherwise, it is a collection
961 +     of bits describing the instruction, notably any relevant hazard
962 +     information.  */
963 +  unsigned long pinfo;
964 +};
965 +
966 +#define INSN_WRITE_GPR_D            0x00000001
967 +#define INSN_WRITE_GPR_RA           0x00000004
968 +#define INSN_WRITE_FPR_D            0x00000008
969 +#define INSN_READ_GPR_S             0x00000040
970 +#define INSN_READ_GPR_T             0x00000080
971 +#define INSN_READ_FPR_S             0x00000100
972 +#define INSN_READ_FPR_T             0x00000200
973 +#define INSN_READ_FPR_R                    0x00000400
974 +/* Instruction is a simple alias (I.E. "move" for daddu/addu/or) */
975 +#define        INSN_ALIAS                  0x00001000
976 +/* Instruction is actually a macro.  It should be ignored by the
977 +   disassembler, and requires special treatment by the assembler.  */
978 +#define INSN_MACRO                  0xffffffff
979 +
980 +/* These are the bits which may be set in the pinfo2 field of an
981 +   instruction. */
982 +
983 +/* MIPS ISA defines, use instead of hardcoding ISA level.  */
984 +
985 +#define       ISA_UNKNOWN     0               /* Gas internal use.  */
986 +#define       ISA_RV32        1
987 +#define       ISA_RV64        2
988 +
989 +#define CPU_UNKNOWN    0
990 +#define CPU_ROCKET32 132
991 +#define CPU_ROCKET64 164
992 +
993 +/* This is a list of macro expanded instructions.
994 +
995 +   _I appended means immediate
996 +   _A appended means address
997 +   _AB appended means address with base register
998 +   _D appended means 64 bit floating point constant
999 +   _S appended means 32 bit floating point constant.  */
1000 +
1001 +enum
1002 +{
1003 +  M_LA_AB,
1004 +  M_J,
1005 +  M_LI,
1006 +  M_NUM_MACROS
1007 +};
1008 +
1009 +
1010 +/* The order of overloaded instructions matters.  Label arguments and
1011 +   register arguments look the same. Instructions that can have either
1012 +   for arguments must apear in the correct order in this table for the
1013 +   assembler to pick the right one. In other words, entries with
1014 +   immediate operands must apear after the same instruction with
1015 +   registers.
1016 +
1017 +   Many instructions are short hand for other instructions (i.e., The
1018 +   jal <register> instruction is short for jalr <register>).  */
1019 +
1020 +extern const struct riscv_opcode riscv_builtin_opcodes[];
1021 +extern const int bfd_riscv_num_builtin_opcodes;
1022 +extern struct riscv_opcode *riscv_opcodes;
1023 +extern int bfd_riscv_num_opcodes;
1024 +#define NUMOPCODES bfd_riscv_num_opcodes
1025 +
1026 +#endif /* _MIPS_H_ */
1027 diff --git a/gcc-4.6.1/gcc/config/riscv/predicates.md b/gcc-4.6.1/gcc/config/riscv/predicates.md
1028 new file mode 100644
1029 index 0000000..14ee358
1030 --- /dev/null
1031 +++ gcc-4.6.1/gcc/config/riscv/predicates.md
1032 @@ -0,0 +1,191 @@
1033 +;; Predicate definitions for MIPS.
1034 +;; Copyright (C) 2004, 2007, 2008 Free Software Foundation, Inc.
1035 +;;
1036 +;; This file is part of GCC.
1037 +;;
1038 +;; GCC is free software; you can redistribute it and/or modify
1039 +;; it under the terms of the GNU General Public License as published by
1040 +;; the Free Software Foundation; either version 3, or (at your option)
1041 +;; any later version.
1042 +;;
1043 +;; GCC is distributed in the hope that it will be useful,
1044 +;; but WITHOUT ANY WARRANTY; without even the implied warranty of
1045 +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1046 +;; GNU General Public License for more details.
1047 +;;
1048 +;; You should have received a copy of the GNU General Public License
1049 +;; along with GCC; see the file COPYING3.  If not see
1050 +;; <http://www.gnu.org/licenses/>.
1051 +
1052 +(define_predicate "const_arith_operand"
1053 +  (and (match_code "const_int")
1054 +       (match_test "SMALL_OPERAND (INTVAL (op))")))
1055 +
1056 +(define_predicate "arith_operand"
1057 +  (ior (match_operand 0 "const_arith_operand")
1058 +       (match_operand 0 "register_operand")))
1059 +
1060 +(define_predicate "sle_operand"
1061 +  (and (match_code "const_int")
1062 +       (match_test "SMALL_OPERAND (INTVAL (op) + 1)")))
1063 +
1064 +(define_predicate "sleu_operand"
1065 +  (and (match_operand 0 "sle_operand")
1066 +       (match_test "INTVAL (op) + 1 != 0")))
1067 +
1068 +(define_predicate "const_0_operand"
1069 +  (and (match_code "const_int,const_double,const_vector")
1070 +       (match_test "op == CONST0_RTX (GET_MODE (op))")))
1071 +
1072 +(define_predicate "reg_or_0_operand"
1073 +  (ior (match_operand 0 "const_0_operand")
1074 +       (match_operand 0 "register_operand")))
1075 +
1076 +(define_predicate "const_1_operand"
1077 +  (and (match_code "const_int,const_double,const_vector")
1078 +       (match_test "op == CONST1_RTX (GET_MODE (op))")))
1079 +
1080 +(define_predicate "reg_or_1_operand"
1081 +  (ior (match_operand 0 "const_1_operand")
1082 +       (match_operand 0 "register_operand")))
1083 +
1084 +;; This is used for indexing into vectors, and hence only accepts const_int.
1085 +(define_predicate "const_0_or_1_operand"
1086 +  (and (match_code "const_int")
1087 +       (ior (match_test "op == CONST0_RTX (GET_MODE (op))")
1088 +           (match_test "op == CONST1_RTX (GET_MODE (op))"))))
1089 +
1090 +(define_special_predicate "pc_or_label_operand"
1091 +  (match_code "pc,label_ref"))
1092 +
1093 +(define_predicate "const_call_insn_operand"
1094 +  (match_code "const,symbol_ref,label_ref")
1095 +{
1096 +  enum mips_symbol_type symbol_type;
1097 +
1098 +  if (!mips_symbolic_constant_p (op, &symbol_type))
1099 +    return false;
1100 +
1101 +  if (symbol_type == SYMBOL_ABSOLUTE)
1102 +    {
1103 +      if (GET_CODE (op) == SYMBOL_REF)
1104 +       {
1105 +         if (flag_pic && !riscv_symbol_binds_local_p (op))
1106 +           return false;
1107 +         if (SYMBOL_REF_LONG_CALL_P (op))
1108 +           return false;
1109 +       }
1110 +      return true;
1111 +    }
1112 +
1113 +  return false;
1114 +})
1115 +
1116 +(define_predicate "call_insn_operand"
1117 +  (ior (match_operand 0 "const_call_insn_operand")
1118 +       (match_operand 0 "register_operand")))
1119 +
1120 +;; A legitimate CONST_INT operand that takes more than one instruction
1121 +;; to load.
1122 +(define_predicate "splittable_const_int_operand"
1123 +  (match_code "const_int")
1124 +{
1125 +  /* Don't handle multi-word moves this way; we don't want to introduce
1126 +     the individual word-mode moves until after reload.  */
1127 +  if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
1128 +    return false;
1129 +
1130 +  /* Otherwise check whether the constant can be loaded in a single
1131 +     instruction.  */
1132 +  return !LUI_INT (op) && !SMALL_INT (op);
1133 +})
1134 +
1135 +(define_predicate "move_operand"
1136 +  (match_operand 0 "general_operand")
1137 +{
1138 +  enum mips_symbol_type symbol_type;
1139 +
1140 +  /* The thinking here is as follows:
1141 +
1142 +     (1) The move expanders should split complex load sequences into
1143 +        individual instructions.  Those individual instructions can
1144 +        then be optimized by all rtl passes.
1145 +
1146 +     (2) The target of pre-reload load sequences should not be used
1147 +        to store temporary results.  If the target register is only
1148 +        assigned one value, reload can rematerialize that value
1149 +        on demand, rather than spill it to the stack.
1150 +
1151 +     (3) If we allowed pre-reload passes like combine and cse to recreate
1152 +        complex load sequences, we would want to be able to split the
1153 +        sequences before reload as well, so that the pre-reload scheduler
1154 +        can see the individual instructions.  This falls foul of (2);
1155 +        the splitter would be forced to reuse the target register for
1156 +        intermediate results.
1157 +
1158 +     (4) We want to define complex load splitters for combine.  These
1159 +        splitters can request a temporary scratch register, which avoids
1160 +        the problem in (2).  They allow things like:
1161 +
1162 +             (set (reg T1) (high SYM))
1163 +             (set (reg T2) (low (reg T1) SYM))
1164 +             (set (reg X) (plus (reg T2) (const_int OFFSET)))
1165 +
1166 +        to be combined into:
1167 +
1168 +             (set (reg T3) (high SYM+OFFSET))
1169 +             (set (reg X) (lo_sum (reg T3) SYM+OFFSET))
1170 +
1171 +        if T2 is only used this once.  */
1172 +  switch (GET_CODE (op))
1173 +    {
1174 +    case CONST_INT:
1175 +      return !splittable_const_int_operand (op, mode);
1176 +
1177 +    case CONST:
1178 +    case SYMBOL_REF:
1179 +    case LABEL_REF:
1180 +      return (mips_symbolic_constant_p (op, &symbol_type)
1181 +             && !mips_split_p[symbol_type]);
1182 +
1183 +    case HIGH:
1184 +      op = XEXP (op, 0);
1185 +      return mips_symbolic_constant_p (op, &symbol_type);
1186 +
1187 +    default:
1188 +      return true;
1189 +    }
1190 +})
1191 +
1192 +(define_predicate "consttable_operand"
1193 +  (match_test "CONSTANT_P (op)"))
1194 +
1195 +(define_predicate "symbolic_operand"
1196 +  (match_code "const,symbol_ref,label_ref")
1197 +{
1198 +  enum mips_symbol_type type;
1199 +  return mips_symbolic_constant_p (op, &type);
1200 +})
1201 +
1202 +(define_predicate "absolute_symbolic_operand"
1203 +  (match_code "const,symbol_ref,label_ref")
1204 +{
1205 +  enum mips_symbol_type type;
1206 +  return (mips_symbolic_constant_p (op, &type)
1207 +         && type == SYMBOL_ABSOLUTE);
1208 +})
1209 +
1210 +(define_predicate "symbol_ref_operand"
1211 +  (match_code "symbol_ref"))
1212 +
1213 +(define_predicate "equality_operator"
1214 +  (match_code "eq,ne"))
1215 +
1216 +(define_predicate "order_operator"
1217 +  (match_code "eq,ne,lt,ltu,le,leu,ge,geu,gt,gtu"))
1218 +
1219 +(define_predicate "fp_order_operator"
1220 +  (match_code "eq,lt,le,gt,ge"))
1221 +
1222 +(define_predicate "fp_unorder_operator"
1223 +  (match_code "ordered,unordered"))
1224 diff --git a/gcc-4.6.1/gcc/config/riscv/riscv-ftypes.def b/gcc-4.6.1/gcc/config/riscv/riscv-ftypes.def
1225 new file mode 100644
1226 index 0000000..69f1cae
1227 --- /dev/null
1228 +++ gcc-4.6.1/gcc/config/riscv/riscv-ftypes.def
1229 @@ -0,0 +1,157 @@
1230 +/* Definitions of prototypes for MIPS built-in functions.  -*- C -*-
1231 +   Copyright (C) 2007, 2008
1232 +   Free Software Foundation, Inc.
1233 +
1234 +This file is part of GCC.
1235 +
1236 +GCC is free software; you can redistribute it and/or modify
1237 +it under the terms of the GNU General Public License as published by
1238 +the Free Software Foundation; either version 3, or (at your option)
1239 +any later version.
1240 +
1241 +GCC is distributed in the hope that it will be useful,
1242 +but WITHOUT ANY WARRANTY; without even the implied warranty of
1243 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1244 +GNU General Public License for more details.
1245 +
1246 +You should have received a copy of the GNU General Public License
1247 +along with GCC; see the file COPYING3.  If not see
1248 +<http://www.gnu.org/licenses/>.  */
1249 +
1250 +/* Invoke DEF_MIPS_FTYPE (NARGS, LIST) for each prototype used by
1251 +   MIPS built-in functions, where:
1252 +
1253 +      NARGS is the number of arguments.
1254 +      LIST contains the return-type code followed by the codes for each
1255 +        argument type.
1256 +
1257 +   Argument- and return-type codes are either modes or one of the following:
1258 +
1259 +      VOID for void_type_node
1260 +      INT for integer_type_node
1261 +      POINTER for ptr_type_node
1262 +
1263 +   (we don't use PTR because that's a ANSI-compatibillity macro).
1264 +
1265 +   Please keep this list lexicographically sorted by the LIST argument.  */
1266 +DEF_MIPS_FTYPE (1, (DF, DF))
1267 +DEF_MIPS_FTYPE (2, (DF, DF, DF))
1268 +
1269 +DEF_MIPS_FTYPE (2, (DI, DI, DI))
1270 +DEF_MIPS_FTYPE (2, (DI, DI, SI))
1271 +DEF_MIPS_FTYPE (3, (DI, DI, SI, SI))
1272 +DEF_MIPS_FTYPE (3, (DI, DI, USI, USI))
1273 +DEF_MIPS_FTYPE (3, (DI, DI, V2HI, V2HI))
1274 +DEF_MIPS_FTYPE (3, (DI, DI, V4QI, V4QI))
1275 +DEF_MIPS_FTYPE (2, (DI, SI, SI))
1276 +DEF_MIPS_FTYPE (2, (DI, USI, USI))
1277 +
1278 +DEF_MIPS_FTYPE (2, (INT, DF, DF))
1279 +DEF_MIPS_FTYPE (2, (INT, SF, SF))
1280 +DEF_MIPS_FTYPE (2, (INT, V2SF, V2SF))
1281 +DEF_MIPS_FTYPE (4, (INT, V2SF, V2SF, V2SF, V2SF))
1282 +
1283 +DEF_MIPS_FTYPE (2, (SI, DI, SI))
1284 +DEF_MIPS_FTYPE (2, (SI, POINTER, SI))
1285 +DEF_MIPS_FTYPE (1, (SI, SI))
1286 +DEF_MIPS_FTYPE (2, (SI, SI, SI))
1287 +DEF_MIPS_FTYPE (3, (SI, SI, SI, SI))
1288 +DEF_MIPS_FTYPE (1, (SI, V2HI))
1289 +DEF_MIPS_FTYPE (2, (SI, V2HI, V2HI))
1290 +DEF_MIPS_FTYPE (1, (SI, V4QI))
1291 +DEF_MIPS_FTYPE (2, (SI, V4QI, V4QI))
1292 +DEF_MIPS_FTYPE (1, (SI, VOID))
1293 +
1294 +DEF_MIPS_FTYPE (1, (SF, SF))
1295 +DEF_MIPS_FTYPE (2, (SF, SF, SF))
1296 +DEF_MIPS_FTYPE (1, (SF, V2SF))
1297 +
1298 +DEF_MIPS_FTYPE (2, (UDI, UDI, UDI))
1299 +DEF_MIPS_FTYPE (2, (UDI, UV2SI, UV2SI))
1300 +
1301 +DEF_MIPS_FTYPE (2, (UV2SI, UV2SI, UQI))
1302 +DEF_MIPS_FTYPE (2, (UV2SI, UV2SI, UV2SI))
1303 +
1304 +DEF_MIPS_FTYPE (2, (UV4HI, UV4HI, UQI))
1305 +DEF_MIPS_FTYPE (2, (UV4HI, UV4HI, USI))
1306 +DEF_MIPS_FTYPE (3, (UV4HI, UV4HI, UV4HI, UQI))
1307 +DEF_MIPS_FTYPE (3, (UV4HI, UV4HI, UV4HI, USI))
1308 +DEF_MIPS_FTYPE (2, (UV4HI, UV4HI, UV4HI))
1309 +DEF_MIPS_FTYPE (1, (UV4HI, UV8QI))
1310 +DEF_MIPS_FTYPE (2, (UV4HI, UV8QI, UV8QI))
1311 +
1312 +DEF_MIPS_FTYPE (2, (UV8QI, UV4HI, UV4HI))
1313 +DEF_MIPS_FTYPE (1, (UV8QI, UV8QI))
1314 +DEF_MIPS_FTYPE (2, (UV8QI, UV8QI, UV8QI))
1315 +
1316 +DEF_MIPS_FTYPE (1, (V2HI, SI))
1317 +DEF_MIPS_FTYPE (2, (V2HI, SI, SI))
1318 +DEF_MIPS_FTYPE (3, (V2HI, SI, SI, SI))
1319 +DEF_MIPS_FTYPE (1, (V2HI, V2HI))
1320 +DEF_MIPS_FTYPE (2, (V2HI, V2HI, SI))
1321 +DEF_MIPS_FTYPE (2, (V2HI, V2HI, V2HI))
1322 +DEF_MIPS_FTYPE (1, (V2HI, V4QI))
1323 +DEF_MIPS_FTYPE (2, (V2HI, V4QI, V2HI))
1324 +
1325 +DEF_MIPS_FTYPE (2, (V2SF, SF, SF))
1326 +DEF_MIPS_FTYPE (1, (V2SF, V2SF))
1327 +DEF_MIPS_FTYPE (2, (V2SF, V2SF, V2SF))
1328 +DEF_MIPS_FTYPE (3, (V2SF, V2SF, V2SF, INT))
1329 +DEF_MIPS_FTYPE (4, (V2SF, V2SF, V2SF, V2SF, V2SF))
1330 +
1331 +DEF_MIPS_FTYPE (2, (V2SI, V2SI, UQI))
1332 +DEF_MIPS_FTYPE (2, (V2SI, V2SI, V2SI))
1333 +DEF_MIPS_FTYPE (2, (V2SI, V4HI, V4HI))
1334 +
1335 +DEF_MIPS_FTYPE (2, (V4HI, V2SI, V2SI))
1336 +DEF_MIPS_FTYPE (2, (V4HI, V4HI, UQI))
1337 +DEF_MIPS_FTYPE (2, (V4HI, V4HI, USI))
1338 +DEF_MIPS_FTYPE (2, (V4HI, V4HI, V4HI))
1339 +DEF_MIPS_FTYPE (3, (V4HI, V4HI, V4HI, UQI))
1340 +DEF_MIPS_FTYPE (3, (V4HI, V4HI, V4HI, USI))
1341 +
1342 +DEF_MIPS_FTYPE (1, (V4QI, SI))
1343 +DEF_MIPS_FTYPE (2, (V4QI, V2HI, V2HI))
1344 +DEF_MIPS_FTYPE (1, (V4QI, V4QI))
1345 +DEF_MIPS_FTYPE (2, (V4QI, V4QI, SI))
1346 +DEF_MIPS_FTYPE (2, (V4QI, V4QI, V4QI))
1347 +
1348 +DEF_MIPS_FTYPE (2, (V8QI, V4HI, V4HI))
1349 +DEF_MIPS_FTYPE (1, (V8QI, V8QI))
1350 +DEF_MIPS_FTYPE (2, (V8QI, V8QI, V8QI))
1351 +
1352 +DEF_MIPS_FTYPE (2, (VOID, SI, CVPOINTER))
1353 +DEF_MIPS_FTYPE (2, (VOID, SI, SI))
1354 +DEF_MIPS_FTYPE (2, (VOID, V2HI, V2HI))
1355 +DEF_MIPS_FTYPE (2, (VOID, V4QI, V4QI))
1356 +
1357 +/* RISC-V builtin function types */
1358 +
1359 +DEF_MIPS_FTYPE (1, (VDI, CPOINTER))
1360 +DEF_MIPS_FTYPE (1, (VSI, CPOINTER))
1361 +DEF_MIPS_FTYPE (1, (VHI, CPOINTER))
1362 +DEF_MIPS_FTYPE (1, (VQI, CPOINTER))
1363 +DEF_MIPS_FTYPE (1, (VDF, CPOINTER))
1364 +DEF_MIPS_FTYPE (1, (VSF, CPOINTER))
1365 +
1366 +DEF_MIPS_FTYPE (2, (VDI, CPOINTER, DI))
1367 +DEF_MIPS_FTYPE (2, (VSI, CPOINTER, DI))
1368 +DEF_MIPS_FTYPE (2, (VHI, CPOINTER, DI))
1369 +DEF_MIPS_FTYPE (2, (VQI, CPOINTER, DI))
1370 +DEF_MIPS_FTYPE (2, (VDF, CPOINTER, DI))
1371 +DEF_MIPS_FTYPE (2, (VSF, CPOINTER, DI))
1372 +
1373 +DEF_MIPS_FTYPE (2, (VOID, VDI, POINTER))
1374 +DEF_MIPS_FTYPE (2, (VOID, VSI, POINTER))
1375 +DEF_MIPS_FTYPE (2, (VOID, VHI, POINTER))
1376 +DEF_MIPS_FTYPE (2, (VOID, VQI, POINTER))
1377 +DEF_MIPS_FTYPE (2, (VOID, VDF, POINTER))
1378 +DEF_MIPS_FTYPE (2, (VOID, VSF, POINTER))
1379 +
1380 +DEF_MIPS_FTYPE (3, (VOID, VDI, POINTER, DI))
1381 +DEF_MIPS_FTYPE (3, (VOID, VSI, POINTER, DI))
1382 +DEF_MIPS_FTYPE (3, (VOID, VHI, POINTER, DI))
1383 +DEF_MIPS_FTYPE (3, (VOID, VQI, POINTER, DI))
1384 +DEF_MIPS_FTYPE (3, (VOID, VDF, POINTER, DI))
1385 +DEF_MIPS_FTYPE (3, (VOID, VSF, POINTER, DI))
1386 +
1387 diff --git a/gcc-4.6.1/gcc/config/riscv/riscv-modes.def b/gcc-4.6.1/gcc/config/riscv/riscv-modes.def
1388 new file mode 100644
1389 index 0000000..7848f7c
1390 --- /dev/null
1391 +++ gcc-4.6.1/gcc/config/riscv/riscv-modes.def
1392 @@ -0,0 +1,101 @@
1393 +/* MIPS extra machine modes. 
1394 +   Copyright (C) 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
1395 +
1396 +This file is part of GCC.
1397 +
1398 +GCC is free software; you can redistribute it and/or modify
1399 +it under the terms of the GNU General Public License as published by
1400 +the Free Software Foundation; either version 3, or (at your option)
1401 +any later version.
1402 +
1403 +GCC is distributed in the hope that it will be useful,
1404 +but WITHOUT ANY WARRANTY; without even the implied warranty of
1405 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1406 +GNU General Public License for more details.
1407 +
1408 +You should have received a copy of the GNU General Public License
1409 +along with GCC; see the file COPYING3.  If not see
1410 +<http://www.gnu.org/licenses/>.  */
1411 +
1412 +/* MIPS has a quirky almost-IEEE format for all its
1413 +   floating point.  */
1414 +RESET_FLOAT_FORMAT (SF, mips_single_format);
1415 +RESET_FLOAT_FORMAT (DF, mips_double_format);
1416 +
1417 +/* Irix6 will override this via MIPS_TFMODE_FORMAT.  */
1418 +FLOAT_MODE (TF, 16, mips_quad_format);
1419 +
1420 +/* Vector modes.  */
1421 +VECTOR_MODES (INT, 8);        /*       V8QI V4HI V2SI */
1422 +VECTOR_MODES (FLOAT, 8);      /*            V4HF V2SF */
1423 +VECTOR_MODES (INT, 4);        /*            V4QI V2HI */
1424 +
1425 +VECTOR_MODES (FRACT, 4);       /* V4QQ  V2HQ */
1426 +VECTOR_MODES (UFRACT, 4);      /* V4UQQ V2UHQ */
1427 +VECTOR_MODES (ACCUM, 4);       /*       V2HA */
1428 +VECTOR_MODES (UACCUM, 4);      /*       V2UHA */
1429 +
1430 +/* Paired single comparison instructions use 2 or 4 CC.  */
1431 +CC_MODE (CCV2);
1432 +ADJUST_BYTESIZE (CCV2, 8);
1433 +ADJUST_ALIGNMENT (CCV2, 8);
1434 +
1435 +CC_MODE (CCV4);
1436 +ADJUST_BYTESIZE (CCV4, 16);
1437 +ADJUST_ALIGNMENT (CCV4, 16);
1438 +
1439 +/* Eventually we want to include syscfg.h here so that we can use the
1440 +   common definition of RISCV_SYSCFG_VLEN_MAX, but for now it is not
1441 +   clear how to do this. syscfg.h in in libgloss which is not used when
1442 +   building the actual cross-compiler. We kind of want to use the
1443 +   "version" in sims - the one for native programs instead of riscv
1444 +   programs. Even if we could include syscfg.h though, we would still
1445 +   need to figure out a way to include it in the mips-riscv.md since the
1446 +   machine description file also refers to these modes. */
1447 +
1448 +#define RISCV_SYSCFG_VLEN_MAX 32
1449 +
1450 +/*----------------------------------------------------------------------*/
1451 +/* RISCV_VECTOR_MODE_NAME                                               */
1452 +/*----------------------------------------------------------------------*/
1453 +/* This is a helper macro which creates a riscv vector mode name from
1454 +   the given inner_mode. It does this by concatenating a 'V' prefix, the
1455 +   maximum riscv vector length, and the inner mode together. For
1456 +   example, RISCV_VECTOR_MODE_NAME(SI) should expand to V32SI if the
1457 +   riscv maximum vector length is 32. We need to use the nested macros
1458 +   to make sure RISCV_SYSCFG_VLEN_MAX is expanded _before_
1459 +   concatenation. */
1460 +
1461 +#define RISCV_VECTOR_MODE_NAME_H2( res_ ) res_
1462 +
1463 +#define RISCV_VECTOR_MODE_NAME_H1( arg0_, arg1_, arg2_ ) \
1464 +  RISCV_VECTOR_MODE_NAME_H2( arg0_ ## arg1_ ## arg2_ )
1465 +
1466 +#define RISCV_VECTOR_MODE_NAME_H0( arg0_, arg1_, arg2_ ) \
1467 +  RISCV_VECTOR_MODE_NAME_H1( arg0_, arg1_, arg2_ )
1468 +
1469 +#define RISCV_VECTOR_MODE_NAME( inner_mode_ ) \
1470 +  RISCV_VECTOR_MODE_NAME_H0( V, RISCV_SYSCFG_VLEN_MAX, inner_mode_ )
1471 +
1472 +/*----------------------------------------------------------------------*/
1473 +/* RISC-V Vector Modes                                                   */
1474 +/*----------------------------------------------------------------------*/
1475 +
1476 +VECTOR_MODE( INT,   DI, RISCV_SYSCFG_VLEN_MAX );
1477 +VECTOR_MODE( INT,   SI, RISCV_SYSCFG_VLEN_MAX );
1478 +VECTOR_MODE( INT,   HI, RISCV_SYSCFG_VLEN_MAX );
1479 +VECTOR_MODE( INT,   QI, RISCV_SYSCFG_VLEN_MAX );
1480 +VECTOR_MODE( FLOAT, DF, RISCV_SYSCFG_VLEN_MAX );
1481 +VECTOR_MODE( FLOAT, SF, RISCV_SYSCFG_VLEN_MAX );
1482 +
1483 +/* By default, vector types are forced to be aligned to the full vector
1484 +   size but in riscv we just need them to be aligned to the element
1485 +   size. */
1486 +
1487 +ADJUST_ALIGNMENT( RISCV_VECTOR_MODE_NAME(DI), 8 );
1488 +ADJUST_ALIGNMENT( RISCV_VECTOR_MODE_NAME(SI), 4 );
1489 +ADJUST_ALIGNMENT( RISCV_VECTOR_MODE_NAME(HI), 2 );
1490 +ADJUST_ALIGNMENT( RISCV_VECTOR_MODE_NAME(QI), 1 );
1491 +ADJUST_ALIGNMENT( RISCV_VECTOR_MODE_NAME(DF), 8 );
1492 +ADJUST_ALIGNMENT( RISCV_VECTOR_MODE_NAME(SF), 4 );
1493 +
1494 diff --git a/gcc-4.6.1/gcc/config/riscv/riscv-opc.h b/gcc-4.6.1/gcc/config/riscv/riscv-opc.h
1495 new file mode 100644
1496 index 0000000..19e20b9
1497 --- /dev/null
1498 +++ gcc-4.6.1/gcc/config/riscv/riscv-opc.h
1499 @@ -0,0 +1,571 @@
1500 +/* Automatically generated by parse-opcodes */
1501 +#define MATCH_MOVN 0x6f7
1502 +#define  MASK_MOVN 0x1ffff
1503 +#define MATCH_VFSSTW 0x150f
1504 +#define  MASK_VFSSTW 0x1ffff
1505 +#define MATCH_REMUW 0x7bb
1506 +#define  MASK_REMUW 0x1ffff
1507 +#define MATCH_FMIN_D 0x180d3
1508 +#define  MASK_FMIN_D 0x1ffff
1509 +#define MATCH_LR_W 0x1012b
1510 +#define  MASK_LR_W 0x3fffff
1511 +#define MATCH_VLSTHU 0x128b
1512 +#define  MASK_VLSTHU 0x1ffff
1513 +#define MATCH_C_SWSP 0x8
1514 +#define  MASK_C_SWSP 0x1f
1515 +#define MATCH_BLTU 0x363
1516 +#define  MASK_BLTU 0x3ff
1517 +#define MATCH_VLSEGSTWU 0xb0b
1518 +#define  MASK_VLSEGSTWU 0xfff
1519 +#define MATCH_VVCFG 0x473
1520 +#define  MASK_VVCFG 0xf801ffff
1521 +#define MATCH_MOVZ 0x2f7
1522 +#define  MASK_MOVZ 0x1ffff
1523 +#define MATCH_C_LD 0x9
1524 +#define  MASK_C_LD 0x1f
1525 +#define MATCH_C_SRLI32 0xc19
1526 +#define  MASK_C_SRLI32 0x1c1f
1527 +#define MATCH_FMIN_S 0x18053
1528 +#define  MASK_FMIN_S 0x1ffff
1529 +#define MATCH_C_LW0 0x12
1530 +#define  MASK_C_LW0 0x801f
1531 +#define MATCH_SLLIW 0x9b
1532 +#define  MASK_SLLIW 0x3f83ff
1533 +#define MATCH_LB 0x3
1534 +#define  MASK_LB 0x3ff
1535 +#define MATCH_VLWU 0x30b
1536 +#define  MASK_VLWU 0x3fffff
1537 +#define MATCH_FCVT_S_WU 0xf053
1538 +#define  MASK_FCVT_S_WU 0x3ff1ff
1539 +#define MATCH_FCVT_D_L 0xc0d3
1540 +#define  MASK_FCVT_D_L 0x3ff1ff
1541 +#define MATCH_LH 0x83
1542 +#define  MASK_LH 0x3ff
1543 +#define MATCH_FCVT_D_W 0xe0d3
1544 +#define  MASK_FCVT_D_W 0x3ff1ff
1545 +#define MATCH_LW 0x103
1546 +#define  MASK_LW 0x3ff
1547 +#define MATCH_ADD 0x33
1548 +#define  MASK_ADD 0x1ffff
1549 +#define MATCH_FCVT_D_S 0x100d3
1550 +#define  MASK_FCVT_D_S 0x3ff1ff
1551 +#define MATCH_MFPCR 0x17b
1552 +#define  MASK_MFPCR 0x3fffff
1553 +#define MATCH_C_FSD 0x18
1554 +#define  MASK_C_FSD 0x1f
1555 +#define MATCH_FMAX_D 0x190d3
1556 +#define  MASK_FMAX_D 0x1ffff
1557 +#define MATCH_BNE 0xe3
1558 +#define  MASK_BNE 0x3ff
1559 +#define MATCH_RDCYCLE 0x277
1560 +#define  MASK_RDCYCLE 0x7ffffff
1561 +#define MATCH_FCVT_S_D 0x11053
1562 +#define  MASK_FCVT_S_D 0x3ff1ff
1563 +#define MATCH_VLH 0x8b
1564 +#define  MASK_VLH 0x3fffff
1565 +#define MATCH_BGEU 0x3e3
1566 +#define  MASK_BGEU 0x3ff
1567 +#define MATCH_VFLSTD 0x158b
1568 +#define  MASK_VFLSTD 0x1ffff
1569 +#define MATCH_C_LI 0x0
1570 +#define  MASK_C_LI 0x1f
1571 +#define MATCH_FADD_D 0xd3
1572 +#define  MASK_FADD_D 0x1f1ff
1573 +#define MATCH_SLTIU 0x193
1574 +#define  MASK_SLTIU 0x3ff
1575 +#define MATCH_MTPCR 0x1fb
1576 +#define  MASK_MTPCR 0x1ffff
1577 +#define MATCH_VLB 0xb
1578 +#define  MASK_VLB 0x3fffff
1579 +#define MATCH_STOP 0x177
1580 +#define  MASK_STOP 0xffffffff
1581 +#define MATCH_VLD 0x18b
1582 +#define  MASK_VLD 0x3fffff
1583 +#define MATCH_C_SLLI 0x19
1584 +#define  MASK_C_SLLI 0x1c1f
1585 +#define MATCH_BREAK 0xf7
1586 +#define  MASK_BREAK 0xffffffff
1587 +#define MATCH_CFLUSH 0x2fb
1588 +#define  MASK_CFLUSH 0xffffffff
1589 +#define MATCH_FCVT_S_W 0xe053
1590 +#define  MASK_FCVT_S_W 0x3ff1ff
1591 +#define MATCH_VFLSTW 0x150b
1592 +#define  MASK_VFLSTW 0x1ffff
1593 +#define MATCH_MUL 0x433
1594 +#define  MASK_MUL 0x1ffff
1595 +#define MATCH_C_LW 0xa
1596 +#define  MASK_C_LW 0x1f
1597 +#define MATCH_VXCPTEVAC 0x237b
1598 +#define  MASK_VXCPTEVAC 0xf83fffff
1599 +#define MATCH_VLW 0x10b
1600 +#define  MASK_VLW 0x3fffff
1601 +#define MATCH_VSSEGSTW 0x90f
1602 +#define  MASK_VSSEGSTW 0xfff
1603 +#define MATCH_AMOMINU_D 0x19ab
1604 +#define  MASK_AMOMINU_D 0x1ffff
1605 +#define MATCH_C_SDSP 0x6
1606 +#define  MASK_C_SDSP 0x1f
1607 +#define MATCH_UTIDX 0x1f7
1608 +#define  MASK_UTIDX 0x7ffffff
1609 +#define MATCH_SRLI 0x293
1610 +#define  MASK_SRLI 0x3f03ff
1611 +#define MATCH_C_SRLI 0x819
1612 +#define  MASK_C_SRLI 0x1c1f
1613 +#define MATCH_C_LDSP 0x4
1614 +#define  MASK_C_LDSP 0x1f
1615 +#define MATCH_C_FLW 0x14
1616 +#define  MASK_C_FLW 0x1f
1617 +#define MATCH_C_SRAI32 0x1419
1618 +#define  MASK_C_SRAI32 0x1c1f
1619 +#define MATCH_AMOMINU_W 0x192b
1620 +#define  MASK_AMOMINU_W 0x1ffff
1621 +#define MATCH_DIVUW 0x6bb
1622 +#define  MASK_DIVUW 0x1ffff
1623 +#define MATCH_MULW 0x43b
1624 +#define  MASK_MULW 0x1ffff
1625 +#define MATCH_VSSEGSTD 0x98f
1626 +#define  MASK_VSSEGSTD 0xfff
1627 +#define MATCH_SRLW 0x2bb
1628 +#define  MASK_SRLW 0x1ffff
1629 +#define MATCH_VSSEGSTB 0x80f
1630 +#define  MASK_VSSEGSTB 0xfff
1631 +#define MATCH_MFTX_D 0x1c0d3
1632 +#define  MASK_MFTX_D 0x3fffff
1633 +#define MATCH_DIV 0x633
1634 +#define  MASK_DIV 0x1ffff
1635 +#define MATCH_VTCFG 0xc73
1636 +#define  MASK_VTCFG 0xf801ffff
1637 +#define MATCH_MFTX_S 0x1c053
1638 +#define  MASK_MFTX_S 0x3fffff
1639 +#define MATCH_VSSEGSTH 0x88f
1640 +#define  MASK_VSSEGSTH 0xfff
1641 +#define MATCH_VVCFGIVL 0xf3
1642 +#define  MASK_VVCFGIVL 0x3ff
1643 +#define MATCH_J 0x67
1644 +#define  MASK_J 0x7f
1645 +#define MATCH_FENCE 0x12f
1646 +#define  MASK_FENCE 0x3ff
1647 +#define MATCH_VSW 0x10f
1648 +#define  MASK_VSW 0x3fffff
1649 +#define MATCH_FNMSUB_S 0x4b
1650 +#define  MASK_FNMSUB_S 0x1ff
1651 +#define MATCH_VFSSEGSTD 0xd8f
1652 +#define  MASK_VFSSEGSTD 0xfff
1653 +#define MATCH_FCVT_L_S 0x8053
1654 +#define  MASK_FCVT_L_S 0x3ff1ff
1655 +#define MATCH_FLE_S 0x17053
1656 +#define  MASK_FLE_S 0x1ffff
1657 +#define MATCH_FENCE_V_L 0x22f
1658 +#define  MASK_FENCE_V_L 0x3ff
1659 +#define MATCH_VSB 0xf
1660 +#define  MASK_VSB 0x3fffff
1661 +#define MATCH_MFFSR 0x1d053
1662 +#define  MASK_MFFSR 0x7ffffff
1663 +#define MATCH_FDIV_S 0x3053
1664 +#define  MASK_FDIV_S 0x1f1ff
1665 +#define MATCH_VLSTBU 0x120b
1666 +#define  MASK_VLSTBU 0x1ffff
1667 +#define MATCH_VSETVL 0x2f3
1668 +#define  MASK_VSETVL 0x3fffff
1669 +#define MATCH_FLE_D 0x170d3
1670 +#define  MASK_FLE_D 0x1ffff
1671 +#define MATCH_FENCE_I 0xaf
1672 +#define  MASK_FENCE_I 0x3ff
1673 +#define MATCH_VLSEGBU 0x220b
1674 +#define  MASK_VLSEGBU 0x1ffff
1675 +#define MATCH_FNMSUB_D 0xcb
1676 +#define  MASK_FNMSUB_D 0x1ff
1677 +#define MATCH_ADDW 0x3b
1678 +#define  MASK_ADDW 0x1ffff
1679 +#define MATCH_SLL 0xb3
1680 +#define  MASK_SLL 0x1ffff
1681 +#define MATCH_XOR 0x233
1682 +#define  MASK_XOR 0x1ffff
1683 +#define MATCH_SUB 0x10033
1684 +#define  MASK_SUB 0x1ffff
1685 +#define MATCH_ERET 0x27b
1686 +#define  MASK_ERET 0xffffffff
1687 +#define MATCH_BLT 0x263
1688 +#define  MASK_BLT 0x3ff
1689 +#define MATCH_VSSTW 0x110f
1690 +#define  MASK_VSSTW 0x1ffff
1691 +#define MATCH_MTFSR 0x1f053
1692 +#define  MASK_MTFSR 0x3fffff
1693 +#define MATCH_VSSTH 0x108f
1694 +#define  MASK_VSSTH 0x1ffff
1695 +#define MATCH_SC_W 0x1052b
1696 +#define  MASK_SC_W 0x1ffff
1697 +#define MATCH_REM 0x733
1698 +#define  MASK_REM 0x1ffff
1699 +#define MATCH_SRLIW 0x29b
1700 +#define  MASK_SRLIW 0x3f83ff
1701 +#define MATCH_LUI 0x37
1702 +#define  MASK_LUI 0x7f
1703 +#define MATCH_VSSTB 0x100f
1704 +#define  MASK_VSSTB 0x1ffff
1705 +#define MATCH_FCVT_S_LU 0xd053
1706 +#define  MASK_FCVT_S_LU 0x3ff1ff
1707 +#define MATCH_VSSTD 0x118f
1708 +#define  MASK_VSSTD 0x1ffff
1709 +#define MATCH_ADDI 0x13
1710 +#define  MASK_ADDI 0x3ff
1711 +#define MATCH_VFMST 0x1173
1712 +#define  MASK_VFMST 0x1ffff
1713 +#define MATCH_MULH 0x4b3
1714 +#define  MASK_MULH 0x1ffff
1715 +#define MATCH_FMUL_S 0x2053
1716 +#define  MASK_FMUL_S 0x1f1ff
1717 +#define MATCH_VLSEGSTHU 0xa8b
1718 +#define  MASK_VLSEGSTHU 0xfff
1719 +#define MATCH_SRAI 0x10293
1720 +#define  MASK_SRAI 0x3f03ff
1721 +#define MATCH_AMOAND_D 0x9ab
1722 +#define  MASK_AMOAND_D 0x1ffff
1723 +#define MATCH_FLT_D 0x160d3
1724 +#define  MASK_FLT_D 0x1ffff
1725 +#define MATCH_SRAW 0x102bb
1726 +#define  MASK_SRAW 0x1ffff
1727 +#define MATCH_FMUL_D 0x20d3
1728 +#define  MASK_FMUL_D 0x1f1ff
1729 +#define MATCH_LD 0x183
1730 +#define  MASK_LD 0x3ff
1731 +#define MATCH_ORI 0x313
1732 +#define  MASK_ORI 0x3ff
1733 +#define MATCH_FLT_S 0x16053
1734 +#define  MASK_FLT_S 0x1ffff
1735 +#define MATCH_ADDIW 0x1b
1736 +#define  MASK_ADDIW 0x3ff
1737 +#define MATCH_AMOAND_W 0x92b
1738 +#define  MASK_AMOAND_W 0x1ffff
1739 +#define MATCH_FEQ_S 0x15053
1740 +#define  MASK_FEQ_S 0x1ffff
1741 +#define MATCH_FSGNJX_D 0x70d3
1742 +#define  MASK_FSGNJX_D 0x1ffff
1743 +#define MATCH_SRA 0x102b3
1744 +#define  MASK_SRA 0x1ffff
1745 +#define MATCH_C_LWSP 0x5
1746 +#define  MASK_C_LWSP 0x1f
1747 +#define MATCH_BGE 0x2e3
1748 +#define  MASK_BGE 0x3ff
1749 +#define MATCH_C_ADD3 0x1c
1750 +#define  MASK_C_ADD3 0x31f
1751 +#define MATCH_SRAIW 0x1029b
1752 +#define  MASK_SRAIW 0x3f83ff
1753 +#define MATCH_VSSEGD 0x218f
1754 +#define  MASK_VSSEGD 0x1ffff
1755 +#define MATCH_SRL 0x2b3
1756 +#define  MASK_SRL 0x1ffff
1757 +#define MATCH_VENQCMD 0x2b7b
1758 +#define  MASK_VENQCMD 0xf801ffff
1759 +#define MATCH_FSUB_D 0x10d3
1760 +#define  MASK_FSUB_D 0x1f1ff
1761 +#define MATCH_VFMTS 0x1973
1762 +#define  MASK_VFMTS 0x1ffff
1763 +#define MATCH_VENQIMM1 0x2f7b
1764 +#define  MASK_VENQIMM1 0xf801ffff
1765 +#define MATCH_FSGNJX_S 0x7053
1766 +#define  MASK_FSGNJX_S 0x1ffff
1767 +#define MATCH_VFMSV 0x973
1768 +#define  MASK_VFMSV 0x3fffff
1769 +#define MATCH_VENQIMM2 0x337b
1770 +#define  MASK_VENQIMM2 0xf801ffff
1771 +#define MATCH_FCVT_D_WU 0xf0d3
1772 +#define  MASK_FCVT_D_WU 0x3ff1ff
1773 +#define MATCH_VXCPTRESTORE 0x77b
1774 +#define  MASK_VXCPTRESTORE 0xf83fffff
1775 +#define MATCH_VMTS 0x1873
1776 +#define  MASK_VMTS 0x1ffff
1777 +#define MATCH_OR 0x333
1778 +#define  MASK_OR 0x1ffff
1779 +#define MATCH_RDINSTRET 0xa77
1780 +#define  MASK_RDINSTRET 0x7ffffff
1781 +#define MATCH_FCVT_WU_D 0xb0d3
1782 +#define  MASK_FCVT_WU_D 0x3ff1ff
1783 +#define MATCH_SUBW 0x1003b
1784 +#define  MASK_SUBW 0x1ffff
1785 +#define MATCH_JALR_C 0x6b
1786 +#define  MASK_JALR_C 0x3ff
1787 +#define MATCH_FMAX_S 0x19053
1788 +#define  MASK_FMAX_S 0x1ffff
1789 +#define MATCH_AMOMAXU_D 0x1dab
1790 +#define  MASK_AMOMAXU_D 0x1ffff
1791 +#define MATCH_C_SLLIW 0x1819
1792 +#define  MASK_C_SLLIW 0x1c1f
1793 +#define MATCH_JALR_J 0x16b
1794 +#define  MASK_JALR_J 0x3ff
1795 +#define MATCH_C_FLD 0x15
1796 +#define  MASK_C_FLD 0x1f
1797 +#define MATCH_VLSTW 0x110b
1798 +#define  MASK_VLSTW 0x1ffff
1799 +#define MATCH_VLSTH 0x108b
1800 +#define  MASK_VLSTH 0x1ffff
1801 +#define MATCH_XORI 0x213
1802 +#define  MASK_XORI 0x3ff
1803 +#define MATCH_JALR_R 0xeb
1804 +#define  MASK_JALR_R 0x3ff
1805 +#define MATCH_AMOMAXU_W 0x1d2b
1806 +#define  MASK_AMOMAXU_W 0x1ffff
1807 +#define MATCH_FCVT_WU_S 0xb053
1808 +#define  MASK_FCVT_WU_S 0x3ff1ff
1809 +#define MATCH_VLSTB 0x100b
1810 +#define  MASK_VLSTB 0x1ffff
1811 +#define MATCH_VLSTD 0x118b
1812 +#define  MASK_VLSTD 0x1ffff
1813 +#define MATCH_C_LD0 0x8012
1814 +#define  MASK_C_LD0 0x801f
1815 +#define MATCH_RDTIME 0x677
1816 +#define  MASK_RDTIME 0x7ffffff
1817 +#define MATCH_ANDI 0x393
1818 +#define  MASK_ANDI 0x3ff
1819 +#define MATCH_CLEARPCR 0x7b
1820 +#define  MASK_CLEARPCR 0x3ff
1821 +#define MATCH_VENQCNT 0x377b
1822 +#define  MASK_VENQCNT 0xf801ffff
1823 +#define MATCH_FSGNJN_D 0x60d3
1824 +#define  MASK_FSGNJN_D 0x1ffff
1825 +#define MATCH_FNMADD_S 0x4f
1826 +#define  MASK_FNMADD_S 0x1ff
1827 +#define MATCH_JAL 0x6f
1828 +#define  MASK_JAL 0x7f
1829 +#define MATCH_LWU 0x303
1830 +#define  MASK_LWU 0x3ff
1831 +#define MATCH_VLSEGSTBU 0xa0b
1832 +#define  MASK_VLSEGSTBU 0xfff
1833 +#define MATCH_C_BEQ 0x10
1834 +#define  MASK_C_BEQ 0x1f
1835 +#define MATCH_VLHU 0x28b
1836 +#define  MASK_VLHU 0x3fffff
1837 +#define MATCH_VFSSTD 0x158f
1838 +#define  MASK_VFSSTD 0x1ffff
1839 +#define MATCH_C_BNE 0x11
1840 +#define  MASK_C_BNE 0x1f
1841 +#define MATCH_FNMADD_D 0xcf
1842 +#define  MASK_FNMADD_D 0x1ff
1843 +#define MATCH_AMOADD_D 0x1ab
1844 +#define  MASK_AMOADD_D 0x1ffff
1845 +#define MATCH_C_SW 0xd
1846 +#define  MASK_C_SW 0x1f
1847 +#define MATCH_LR_D 0x101ab
1848 +#define  MASK_LR_D 0x3fffff
1849 +#define MATCH_C_MOVE 0x2
1850 +#define  MASK_C_MOVE 0x801f
1851 +#define MATCH_FMOVN 0xef7
1852 +#define  MASK_FMOVN 0x1ffff
1853 +#define MATCH_C_FSW 0x16
1854 +#define  MASK_C_FSW 0x1f
1855 +#define MATCH_C_J 0x8002
1856 +#define  MASK_C_J 0x801f
1857 +#define MATCH_MULHSU 0x533
1858 +#define  MASK_MULHSU 0x1ffff
1859 +#define MATCH_C_SD 0xc
1860 +#define  MASK_C_SD 0x1f
1861 +#define MATCH_AMOADD_W 0x12b
1862 +#define  MASK_AMOADD_W 0x1ffff
1863 +#define MATCH_FCVT_D_LU 0xd0d3
1864 +#define  MASK_FCVT_D_LU 0x3ff1ff
1865 +#define MATCH_AMOMAX_D 0x15ab
1866 +#define  MASK_AMOMAX_D 0x1ffff
1867 +#define MATCH_FSD 0x1a7
1868 +#define  MASK_FSD 0x3ff
1869 +#define MATCH_FCVT_W_D 0xa0d3
1870 +#define  MASK_FCVT_W_D 0x3ff1ff
1871 +#define MATCH_FMOVZ 0xaf7
1872 +#define  MASK_FMOVZ 0x1ffff
1873 +#define MATCH_FEQ_D 0x150d3
1874 +#define  MASK_FEQ_D 0x1ffff
1875 +#define MATCH_C_OR3 0x21c
1876 +#define  MASK_C_OR3 0x31f
1877 +#define MATCH_VMVV 0x73
1878 +#define  MASK_VMVV 0x3fffff
1879 +#define MATCH_VFSSEGSTW 0xd0f
1880 +#define  MASK_VFSSEGSTW 0xfff
1881 +#define MATCH_SLT 0x133
1882 +#define  MASK_SLT 0x1ffff
1883 +#define MATCH_MXTF_D 0x1e0d3
1884 +#define  MASK_MXTF_D 0x3fffff
1885 +#define MATCH_SLLW 0xbb
1886 +#define  MASK_SLLW 0x1ffff
1887 +#define MATCH_AMOOR_D 0xdab
1888 +#define  MASK_AMOOR_D 0x1ffff
1889 +#define MATCH_SLTI 0x113
1890 +#define  MASK_SLTI 0x3ff
1891 +#define MATCH_REMU 0x7b3
1892 +#define  MASK_REMU 0x1ffff
1893 +#define MATCH_FLW 0x107
1894 +#define  MASK_FLW 0x3ff
1895 +#define MATCH_REMW 0x73b
1896 +#define  MASK_REMW 0x1ffff
1897 +#define MATCH_SLTU 0x1b3
1898 +#define  MASK_SLTU 0x1ffff
1899 +#define MATCH_SLLI 0x93
1900 +#define  MASK_SLLI 0x3f03ff
1901 +#define MATCH_C_AND3 0x31c
1902 +#define  MASK_C_AND3 0x31f
1903 +#define MATCH_VSSEGW 0x210f
1904 +#define  MASK_VSSEGW 0x1ffff
1905 +#define MATCH_AMOOR_W 0xd2b
1906 +#define  MASK_AMOOR_W 0x1ffff
1907 +#define MATCH_VSD 0x18f
1908 +#define  MASK_VSD 0x3fffff
1909 +#define MATCH_BEQ 0x63
1910 +#define  MASK_BEQ 0x3ff
1911 +#define MATCH_FLD 0x187
1912 +#define  MASK_FLD 0x3ff
1913 +#define MATCH_MXTF_S 0x1e053
1914 +#define  MASK_MXTF_S 0x3fffff
1915 +#define MATCH_FSUB_S 0x1053
1916 +#define  MASK_FSUB_S 0x1f1ff
1917 +#define MATCH_AND 0x3b3
1918 +#define  MASK_AND 0x1ffff
1919 +#define MATCH_VTCFGIVL 0x1f3
1920 +#define  MASK_VTCFGIVL 0x3ff
1921 +#define MATCH_LBU 0x203
1922 +#define  MASK_LBU 0x3ff
1923 +#define MATCH_VF 0x3f3
1924 +#define  MASK_VF 0xf80003ff
1925 +#define MATCH_VLSEGSTW 0x90b
1926 +#define  MASK_VLSEGSTW 0xfff
1927 +#define MATCH_SYSCALL 0x77
1928 +#define  MASK_SYSCALL 0xffffffff
1929 +#define MATCH_FSGNJ_S 0x5053
1930 +#define  MASK_FSGNJ_S 0x1ffff
1931 +#define MATCH_C_ADDI 0x1
1932 +#define  MASK_C_ADDI 0x1f
1933 +#define MATCH_VFMVV 0x173
1934 +#define  MASK_VFMVV 0x3fffff
1935 +#define MATCH_VLSTWU 0x130b
1936 +#define  MASK_VLSTWU 0x1ffff
1937 +#define MATCH_C_SUB3 0x11c
1938 +#define  MASK_C_SUB3 0x31f
1939 +#define MATCH_VSH 0x8f
1940 +#define  MASK_VSH 0x3fffff
1941 +#define MATCH_VLSEGSTB 0x80b
1942 +#define  MASK_VLSEGSTB 0xfff
1943 +#define MATCH_VXCPTSAVE 0x37b
1944 +#define  MASK_VXCPTSAVE 0xf83fffff
1945 +#define MATCH_VLSEGSTD 0x98b
1946 +#define  MASK_VLSEGSTD 0xfff
1947 +#define MATCH_VFLSEGD 0x258b
1948 +#define  MASK_VFLSEGD 0x1ffff
1949 +#define MATCH_VFLSEGW 0x250b
1950 +#define  MASK_VFLSEGW 0x1ffff
1951 +#define MATCH_VLSEGSTH 0x88b
1952 +#define  MASK_VLSEGSTH 0xfff
1953 +#define MATCH_AMOMAX_W 0x152b
1954 +#define  MASK_AMOMAX_W 0x1ffff
1955 +#define MATCH_FSGNJ_D 0x50d3
1956 +#define  MASK_FSGNJ_D 0x1ffff
1957 +#define MATCH_VFLSEGSTW 0xd0b
1958 +#define  MASK_VFLSEGSTW 0xfff
1959 +#define MATCH_C_SUB 0x801a
1960 +#define  MASK_C_SUB 0x801f
1961 +#define MATCH_MULHU 0x5b3
1962 +#define  MASK_MULHU 0x1ffff
1963 +#define MATCH_FENCE_V_G 0x2af
1964 +#define  MASK_FENCE_V_G 0x3ff
1965 +#define MATCH_VMSV 0x873
1966 +#define  MASK_VMSV 0x3fffff
1967 +#define MATCH_VMST 0x1073
1968 +#define  MASK_VMST 0x1ffff
1969 +#define MATCH_SETPCR 0xfb
1970 +#define  MASK_SETPCR 0x3ff
1971 +#define MATCH_FCVT_LU_S 0x9053
1972 +#define  MASK_FCVT_LU_S 0x3ff1ff
1973 +#define MATCH_VXCPTHOLD 0x277b
1974 +#define  MASK_VXCPTHOLD 0xffffffff
1975 +#define MATCH_FCVT_S_L 0xc053
1976 +#define  MASK_FCVT_S_L 0x3ff1ff
1977 +#define MATCH_VFLSEGSTD 0xd8b
1978 +#define  MASK_VFLSEGSTD 0xfff
1979 +#define MATCH_AUIPC 0x17
1980 +#define  MASK_AUIPC 0x7f
1981 +#define MATCH_C_ADD 0x1a
1982 +#define  MASK_C_ADD 0x801f
1983 +#define MATCH_FCVT_LU_D 0x90d3
1984 +#define  MASK_FCVT_LU_D 0x3ff1ff
1985 +#define MATCH_VFLD 0x58b
1986 +#define  MASK_VFLD 0x3fffff
1987 +#define MATCH_SC_D 0x105ab
1988 +#define  MASK_SC_D 0x1ffff
1989 +#define MATCH_FMADD_S 0x43
1990 +#define  MASK_FMADD_S 0x1ff
1991 +#define MATCH_FCVT_W_S 0xa053
1992 +#define  MASK_FCVT_W_S 0x3ff1ff
1993 +#define MATCH_VSSEGH 0x208f
1994 +#define  MASK_VSSEGH 0x1ffff
1995 +#define MATCH_FSQRT_S 0x4053
1996 +#define  MASK_FSQRT_S 0x3ff1ff
1997 +#define MATCH_VXCPTKILL 0xb7b
1998 +#define  MASK_VXCPTKILL 0xffffffff
1999 +#define MATCH_C_SRAI 0x1019
2000 +#define  MASK_C_SRAI 0x1c1f
2001 +#define MATCH_AMOMIN_W 0x112b
2002 +#define  MASK_AMOMIN_W 0x1ffff
2003 +#define MATCH_FSGNJN_S 0x6053
2004 +#define  MASK_FSGNJN_S 0x1ffff
2005 +#define MATCH_C_SLLI32 0x419
2006 +#define  MASK_C_SLLI32 0x1c1f
2007 +#define MATCH_VLSEGWU 0x230b
2008 +#define  MASK_VLSEGWU 0x1ffff
2009 +#define MATCH_VFSW 0x50f
2010 +#define  MASK_VFSW 0x3fffff
2011 +#define MATCH_AMOSWAP_D 0x5ab
2012 +#define  MASK_AMOSWAP_D 0x1ffff
2013 +#define MATCH_FSQRT_D 0x40d3
2014 +#define  MASK_FSQRT_D 0x3ff1ff
2015 +#define MATCH_VFLW 0x50b
2016 +#define  MASK_VFLW 0x3fffff
2017 +#define MATCH_FDIV_D 0x30d3
2018 +#define  MASK_FDIV_D 0x1f1ff
2019 +#define MATCH_FMADD_D 0xc3
2020 +#define  MASK_FMADD_D 0x1ff
2021 +#define MATCH_DIVW 0x63b
2022 +#define  MASK_DIVW 0x1ffff
2023 +#define MATCH_AMOMIN_D 0x11ab
2024 +#define  MASK_AMOMIN_D 0x1ffff
2025 +#define MATCH_DIVU 0x6b3
2026 +#define  MASK_DIVU 0x1ffff
2027 +#define MATCH_AMOSWAP_W 0x52b
2028 +#define  MASK_AMOSWAP_W 0x1ffff
2029 +#define MATCH_VFSD 0x58f
2030 +#define  MASK_VFSD 0x3fffff
2031 +#define MATCH_FADD_S 0x53
2032 +#define  MASK_FADD_S 0x1f1ff
2033 +#define MATCH_VLSEGB 0x200b
2034 +#define  MASK_VLSEGB 0x1ffff
2035 +#define MATCH_FCVT_L_D 0x80d3
2036 +#define  MASK_FCVT_L_D 0x3ff1ff
2037 +#define MATCH_VLSEGD 0x218b
2038 +#define  MASK_VLSEGD 0x1ffff
2039 +#define MATCH_VLSEGH 0x208b
2040 +#define  MASK_VLSEGH 0x1ffff
2041 +#define MATCH_SW 0x123
2042 +#define  MASK_SW 0x3ff
2043 +#define MATCH_FMSUB_S 0x47
2044 +#define  MASK_FMSUB_S 0x1ff
2045 +#define MATCH_VFSSEGW 0x250f
2046 +#define  MASK_VFSSEGW 0x1ffff
2047 +#define MATCH_C_ADDIW 0x1d
2048 +#define  MASK_C_ADDIW 0x1f
2049 +#define MATCH_LHU 0x283
2050 +#define  MASK_LHU 0x3ff
2051 +#define MATCH_SH 0xa3
2052 +#define  MASK_SH 0x3ff
2053 +#define MATCH_VLSEGW 0x210b
2054 +#define  MASK_VLSEGW 0x1ffff
2055 +#define MATCH_FSW 0x127
2056 +#define  MASK_FSW 0x3ff
2057 +#define MATCH_VLBU 0x20b
2058 +#define  MASK_VLBU 0x3fffff
2059 +#define MATCH_SB 0x23
2060 +#define  MASK_SB 0x3ff
2061 +#define MATCH_FMSUB_D 0xc7
2062 +#define  MASK_FMSUB_D 0x1ff
2063 +#define MATCH_VLSEGHU 0x228b
2064 +#define  MASK_VLSEGHU 0x1ffff
2065 +#define MATCH_VSSEGB 0x200f
2066 +#define  MASK_VSSEGB 0x1ffff
2067 +#define MATCH_VFSSEGD 0x258f
2068 +#define  MASK_VFSSEGD 0x1ffff
2069 +#define MATCH_SD 0x1a3
2070 +#define  MASK_SD 0x3ff
2071 diff --git a/gcc-4.6.1/gcc/config/riscv/riscv-protos.h b/gcc-4.6.1/gcc/config/riscv/riscv-protos.h
2072 new file mode 100644
2073 index 0000000..7852d1f
2074 --- /dev/null
2075 +++ gcc-4.6.1/gcc/config/riscv/riscv-protos.h
2076 @@ -0,0 +1,135 @@
2077 +/* Prototypes of target machine for GNU compiler.  MIPS version.
2078 +   Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
2079 +   1999, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
2080 +   Free Software Foundation, Inc.
2081 +   Contributed by A. Lichnewsky (lich@inria.inria.fr).
2082 +   Changed by Michael Meissner (meissner@osf.org).
2083 +   64-bit r4000 support by Ian Lance Taylor (ian@cygnus.com) and
2084 +   Brendan Eich (brendan@microunity.com).
2085 +
2086 +This file is part of GCC.
2087 +
2088 +GCC is free software; you can redistribute it and/or modify
2089 +it under the terms of the GNU General Public License as published by
2090 +the Free Software Foundation; either version 3, or (at your option)
2091 +any later version.
2092 +
2093 +GCC is distributed in the hope that it will be useful,
2094 +but WITHOUT ANY WARRANTY; without even the implied warranty of
2095 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2096 +GNU General Public License for more details.
2097 +
2098 +You should have received a copy of the GNU General Public License
2099 +along with GCC; see the file COPYING3.  If not see
2100 +<http://www.gnu.org/licenses/>.  */
2101 +
2102 +#ifndef GCC_MIPS_PROTOS_H
2103 +#define GCC_MIPS_PROTOS_H
2104 +
2105 +/* Classifies a SYMBOL_REF, LABEL_REF or UNSPEC address.
2106 +
2107 +   SYMBOL_ABSOLUTE
2108 +       The symbol's value will be calculated using absolute relocations,
2109 +       such as %hi and %lo.
2110 +
2111 +   SYMBOL_TLS
2112 +       A thread-local symbol.
2113 +
2114 +   SYMBOL_TPREL
2115 +       UNSPEC wrappers around SYMBOL_TLS, corresponding to the
2116 +       thread-local storage relocation operators.
2117 +
2118 +   SYMBOL_32_HIGH
2119 +       For a 32-bit symbolic address X, this is the value of %hi(X). */
2120 +enum mips_symbol_type {
2121 +  SYMBOL_ABSOLUTE,
2122 +  SYMBOL_TLS,
2123 +  SYMBOL_TPREL,
2124 +};
2125 +#define NUM_SYMBOL_TYPES (SYMBOL_TPREL + 1)
2126 +
2127 +extern bool mips_symbolic_constant_p (rtx, enum mips_symbol_type *);
2128 +extern int mips_regno_mode_ok_for_base_p (int, enum machine_mode, bool);
2129 +extern int mips_address_insns (rtx, enum machine_mode, bool);
2130 +extern int mips_const_insns (rtx);
2131 +extern int mips_split_const_insns (rtx);
2132 +extern int mips_load_store_insns (rtx, rtx);
2133 +extern rtx mips_emit_move (rtx, rtx);
2134 +extern bool mips_split_symbol (rtx, rtx, enum machine_mode, rtx *);
2135 +extern rtx mips_unspec_address (rtx, enum mips_symbol_type);
2136 +extern void mips_move_integer (rtx, rtx, HOST_WIDE_INT);
2137 +extern bool mips_legitimize_move (enum machine_mode, rtx, rtx);
2138 +extern bool mips_legitimize_vector_move (enum machine_mode, rtx, rtx);
2139 +
2140 +extern rtx mips_subword (rtx, bool);
2141 +extern bool mips_split_64bit_move_p (rtx, rtx);
2142 +extern void mips_split_doubleword_move (rtx, rtx);
2143 +extern const char *mips_output_move (rtx, rtx);
2144 +extern const char *mips_riscv_output_vector_move (enum machine_mode, rtx, rtx);
2145 +#ifdef RTX_CODE
2146 +extern void mips_expand_scc (rtx *);
2147 +extern void mips_expand_conditional_branch (rtx *);
2148 +extern void mips_expand_vcondv2sf (rtx, rtx, rtx, enum rtx_code, rtx, rtx);
2149 +extern void mips_expand_conditional_move (rtx *);
2150 +#endif
2151 +extern rtx mips_expand_call (bool, rtx, rtx, rtx);
2152 +extern void mips_expand_fcc_reload (rtx, rtx, rtx);
2153 +extern void mips_set_return_address (rtx, rtx);
2154 +extern bool mips_expand_block_move (rtx, rtx, rtx);
2155 +extern void mips_expand_synci_loop (rtx, rtx);
2156 +
2157 +extern void mips_init_cumulative_args (CUMULATIVE_ARGS *, tree);
2158 +extern bool mips_pad_arg_upward (enum machine_mode, const_tree);
2159 +extern bool mips_pad_reg_upward (enum machine_mode, tree);
2160 +
2161 +extern bool mips_expand_ext_as_unaligned_load (rtx, rtx, HOST_WIDE_INT,
2162 +                                              HOST_WIDE_INT);
2163 +extern bool mips_expand_ins_as_unaligned_store (rtx, rtx, HOST_WIDE_INT,
2164 +                                               HOST_WIDE_INT);
2165 +extern bool mips_mem_fits_mode_p (enum machine_mode mode, rtx x);
2166 +extern void mips_order_regs_for_local_alloc (void);
2167 +extern HOST_WIDE_INT mips_debugger_offset (rtx, HOST_WIDE_INT);
2168 +
2169 +extern void mips_output_external (FILE *, tree, const char *);
2170 +extern void mips_output_ascii (FILE *, const char *, size_t);
2171 +extern void mips_output_aligned_decl_common (FILE *, tree, const char *,
2172 +                                            unsigned HOST_WIDE_INT,
2173 +                                            unsigned int);
2174 +extern void mips_declare_common_object (FILE *, const char *,
2175 +                                       const char *, unsigned HOST_WIDE_INT,
2176 +                                       unsigned int, bool);
2177 +extern void mips_declare_object (FILE *, const char *, const char *,
2178 +                                const char *, ...) ATTRIBUTE_PRINTF_4;
2179 +extern void mips_declare_object_name (FILE *, const char *, tree);
2180 +extern void mips_finish_declare_object (FILE *, tree, int, int);
2181 +
2182 +extern HOST_WIDE_INT mips_initial_elimination_offset (int, int);
2183 +extern rtx mips_return_addr (int, rtx);
2184 +extern void mips_emit_save_slot_move (rtx, rtx, rtx);
2185 +extern void mips_expand_prologue (void);
2186 +extern void mips_expand_epilogue (bool);
2187 +extern bool mips_can_use_return_insn (void);
2188 +extern rtx mips_function_value (const_tree, const_tree, enum machine_mode);
2189 +
2190 +extern bool mips_cannot_change_mode_class (enum machine_mode,
2191 +                                          enum machine_mode, enum reg_class);
2192 +extern bool mips_modes_tieable_p (enum machine_mode, enum machine_mode);
2193 +extern enum reg_class mips_secondary_reload_class (enum reg_class,
2194 +                                                  enum machine_mode,
2195 +                                                  rtx, bool);
2196 +extern int mips_class_max_nregs (enum reg_class, enum machine_mode);
2197 +
2198 +extern const char *mips_output_conditional_branch (rtx, rtx *, const char *,
2199 +                                                  const char *);
2200 +extern unsigned int mips_hard_regno_nregs (int, enum machine_mode);
2201 +
2202 +extern void irix_asm_output_align (FILE *, unsigned);
2203 +extern const char *current_section_name (void);
2204 +extern unsigned int current_section_flags (void);
2205 +
2206 +extern void mips_expand_vector_init (rtx, rtx);
2207 +
2208 +extern bool mips_epilogue_uses (unsigned int);
2209 +extern bool riscv_symbol_binds_local_p (const_rtx x);
2210 +
2211 +#endif /* ! GCC_MIPS_PROTOS_H */
2212 diff --git a/gcc-4.6.1/gcc/config/riscv/riscv.c b/gcc-4.6.1/gcc/config/riscv/riscv.c
2213 new file mode 100644
2214 index 0000000..26603b4
2215 --- /dev/null
2216 +++ gcc-4.6.1/gcc/config/riscv/riscv.c
2217 @@ -0,0 +1,5958 @@
2218 +/* Subroutines used for MIPS code generation.
2219 +   Copyright (C) 1989, 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998,
2220 +   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
2221 +   2011
2222 +   Free Software Foundation, Inc.
2223 +   Contributed by A. Lichnewsky, lich@inria.inria.fr.
2224 +   Changes by Michael Meissner, meissner@osf.org.
2225 +   64-bit r4000 support by Ian Lance Taylor, ian@cygnus.com, and
2226 +   Brendan Eich, brendan@microunity.com.
2227 +
2228 +This file is part of GCC.
2229 +
2230 +GCC is free software; you can redistribute it and/or modify
2231 +it under the terms of the GNU General Public License as published by
2232 +the Free Software Foundation; either version 3, or (at your option)
2233 +any later version.
2234 +
2235 +GCC is distributed in the hope that it will be useful,
2236 +but WITHOUT ANY WARRANTY; without even the implied warranty of
2237 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2238 +GNU General Public License for more details.
2239 +
2240 +You should have received a copy of the GNU General Public License
2241 +along with GCC; see the file COPYING3.  If not see
2242 +<http://www.gnu.org/licenses/>.  */
2243 +
2244 +#include "config.h"
2245 +#include "system.h"
2246 +#include "coretypes.h"
2247 +#include "tm.h"
2248 +#include "rtl.h"
2249 +#include "regs.h"
2250 +#include "hard-reg-set.h"
2251 +#include "insn-config.h"
2252 +#include "conditions.h"
2253 +#include "insn-attr.h"
2254 +#include "recog.h"
2255 +#include "output.h"
2256 +#include "tree.h"
2257 +#include "function.h"
2258 +#include "expr.h"
2259 +#include "optabs.h"
2260 +#include "libfuncs.h"
2261 +#include "flags.h"
2262 +#include "reload.h"
2263 +#include "tm_p.h"
2264 +#include "ggc.h"
2265 +#include "gstab.h"
2266 +#include "hashtab.h"
2267 +#include "debug.h"
2268 +#include "target.h"
2269 +#include "target-def.h"
2270 +#include "integrate.h"
2271 +#include "langhooks.h"
2272 +#include "cfglayout.h"
2273 +#include "sched-int.h"
2274 +#include "gimple.h"
2275 +#include "bitmap.h"
2276 +#include "diagnostic.h"
2277 +#include "target-globals.h"
2278 +#include <stdint.h>
2279 +
2280 +/*----------------------------------------------------------------------*/
2281 +/* RISCV_SYSCFG_VLEN_MAX                                                */
2282 +/*----------------------------------------------------------------------*/
2283 +/* Eventually we want to include syscfg.h here so that we can use the
2284 +   common definition of RISCV_SYSCFG_VLEN_MAX, but for now it is not
2285 +   clear how to do this. syscfg.h in in libgloss which is not used when
2286 +   building the actual cross-compiler. We kind of want to use the
2287 +   "version" in sims - the one for native programs instead of RISC-V
2288 +   programs. Even if we could include syscfg.h though, we would still
2289 +   need to figure out a way to include it in the mips-riscv.md since the
2290 +   machine description file also refers to these modes. */
2291 +
2292 +#define RISCV_SYSCFG_VLEN_MAX 32
2293 +
2294 +/*----------------------------------------------------------------------*/
2295 +/* MIPS_RISCV_VECTOR_MODE_NAME                                          */
2296 +/*----------------------------------------------------------------------*/
2297 +/* This is a helper macro which creates a RISC-V vector mode name from
2298 +   the given inner_mode. It does this by concatenating a 'V' prefix, the
2299 +   maximum RISC-V vector length, and the inner mode together. For
2300 +   example, MIPS_RISCV_VECTOR_MODE_NAME(SI) should expand to V32SI if
2301 +   the RISC-V maximum vector length is 32. We need to use the nested
2302 +   macros to make sure RISCV_SYSCFG_VLEN_MAX is expanded _before_
2303 +   concatenation. */
2304 +
2305 +#define MIPS_RISCV_VECTOR_MODE_NAME_H2( res_ ) res_
2306 +
2307 +#define MIPS_RISCV_VECTOR_MODE_NAME_H1( arg0_, arg1_ ) \
2308 +  MIPS_RISCV_VECTOR_MODE_NAME_H2( V ## arg0_ ## arg1_ ## mode )
2309 +
2310 +#define MIPS_RISCV_VECTOR_MODE_NAME_H0( arg0_, arg1_ ) \
2311 +  MIPS_RISCV_VECTOR_MODE_NAME_H1( arg0_, arg1_ )
2312 +
2313 +#define MIPS_RISCV_VECTOR_MODE_NAME( inner_mode_ ) \
2314 +  MIPS_RISCV_VECTOR_MODE_NAME_H0( RISCV_SYSCFG_VLEN_MAX, inner_mode_ )
2315 +
2316 +/* True if X is an UNSPEC wrapper around a SYMBOL_REF or LABEL_REF.  */
2317 +#define UNSPEC_ADDRESS_P(X)                                    \
2318 +  (GET_CODE (X) == UNSPEC                                      \
2319 +   && XINT (X, 1) >= UNSPEC_ADDRESS_FIRST                      \
2320 +   && XINT (X, 1) < UNSPEC_ADDRESS_FIRST + NUM_SYMBOL_TYPES)
2321 +
2322 +/* Extract the symbol or label from UNSPEC wrapper X.  */
2323 +#define UNSPEC_ADDRESS(X) \
2324 +  XVECEXP (X, 0, 0)
2325 +
2326 +/* Extract the symbol type from UNSPEC wrapper X.  */
2327 +#define UNSPEC_ADDRESS_TYPE(X) \
2328 +  ((enum mips_symbol_type) (XINT (X, 1) - UNSPEC_ADDRESS_FIRST))
2329 +
2330 +/* The maximum distance between the top of the stack frame and the
2331 +   value $sp has when we save and restore registers.
2332 +
2333 +   The value for normal-mode code must be a SMALL_OPERAND and must
2334 +   preserve the maximum stack alignment.  We therefore use a value
2335 +   of 0x7ff0 in this case.
2336 +
2337 +   MIPS16e SAVE and RESTORE instructions can adjust the stack pointer by
2338 +   up to 0x7f8 bytes and can usually save or restore all the registers
2339 +   that we need to save or restore.  (Note that we can only use these
2340 +   instructions for o32, for which the stack alignment is 8 bytes.)
2341 +
2342 +   We use a maximum gap of 0x100 or 0x400 for MIPS16 code when SAVE and
2343 +   RESTORE are not available.  We can then use unextended instructions
2344 +   to save and restore registers, and to allocate and deallocate the top
2345 +   part of the frame.  */
2346 +#define MIPS_MAX_FIRST_STACK_STEP (RISCV_IMM_REACH/2 - 16)
2347 +
2348 +/* True if INSN is a mips.md pattern or asm statement.  */
2349 +#define USEFUL_INSN_P(INSN)                                            \
2350 +  (NONDEBUG_INSN_P (INSN)                                              \
2351 +   && GET_CODE (PATTERN (INSN)) != USE                                 \
2352 +   && GET_CODE (PATTERN (INSN)) != CLOBBER                             \
2353 +   && GET_CODE (PATTERN (INSN)) != ADDR_VEC                            \
2354 +   && GET_CODE (PATTERN (INSN)) != ADDR_DIFF_VEC)
2355 +
2356 +/* True if bit BIT is set in VALUE.  */
2357 +#define BITSET_P(VALUE, BIT) (((VALUE) & (1 << (BIT))) != 0)
2358 +
2359 +/* Classifies an address.
2360 +
2361 +   ADDRESS_REG
2362 +       A natural register + offset address.  The register satisfies
2363 +       mips_valid_base_register_p and the offset is a const_arith_operand.
2364 +
2365 +   ADDRESS_LO_SUM
2366 +       A LO_SUM rtx.  The first operand is a valid base register and
2367 +       the second operand is a symbolic address.
2368 +
2369 +   ADDRESS_CONST_INT
2370 +       A signed 16-bit constant address.
2371 +
2372 +   ADDRESS_SYMBOLIC:
2373 +       A constant symbolic address.  */
2374 +enum mips_address_type {
2375 +  ADDRESS_REG,
2376 +  ADDRESS_LO_SUM,
2377 +  ADDRESS_CONST_INT,
2378 +  ADDRESS_SYMBOLIC
2379 +};
2380 +
2381 +/* Macros to create an enumeration identifier for a function prototype.  */
2382 +#define MIPS_FTYPE_NAME1(A, B) MIPS_##A##_FTYPE_##B
2383 +#define MIPS_FTYPE_NAME2(A, B, C) MIPS_##A##_FTYPE_##B##_##C
2384 +#define MIPS_FTYPE_NAME3(A, B, C, D) MIPS_##A##_FTYPE_##B##_##C##_##D
2385 +#define MIPS_FTYPE_NAME4(A, B, C, D, E) MIPS_##A##_FTYPE_##B##_##C##_##D##_##E
2386 +
2387 +/* Classifies the prototype of a built-in function.  */
2388 +enum mips_function_type {
2389 +#define DEF_MIPS_FTYPE(NARGS, LIST) MIPS_FTYPE_NAME##NARGS LIST,
2390 +#include "config/riscv/riscv-ftypes.def"
2391 +#undef DEF_MIPS_FTYPE
2392 +  MIPS_MAX_FTYPE_MAX
2393 +};
2394 +
2395 +/* Specifies how a built-in function should be converted into rtl.  */
2396 +enum mips_builtin_type {
2397 +  /* The function corresponds directly to an .md pattern.  The return
2398 +     value is mapped to operand 0 and the arguments are mapped to
2399 +     operands 1 and above.  */
2400 +  MIPS_BUILTIN_DIRECT,
2401 +
2402 +  /* The function corresponds directly to an .md pattern.  There is no return
2403 +     value and the arguments are mapped to operands 0 and above.  */
2404 +  MIPS_BUILTIN_DIRECT_NO_TARGET
2405 +};
2406 +
2407 +/* Information about a function's frame layout.  */
2408 +struct GTY(())  mips_frame_info {
2409 +  /* The size of the frame in bytes.  */
2410 +  HOST_WIDE_INT total_size;
2411 +
2412 +  /* Bit X is set if the function saves or restores GPR X.  */
2413 +  unsigned int mask;
2414 +
2415 +  /* Likewise FPR X.  */
2416 +  unsigned int fmask;
2417 +
2418 +  /* Offsets of fixed-point and floating-point save areas from frame bottom */
2419 +  HOST_WIDE_INT gp_sp_offset;
2420 +  HOST_WIDE_INT fp_sp_offset;
2421 +
2422 +  /* Offset of virtual frame pointer from stack pointer/frame bottom */
2423 +  HOST_WIDE_INT frame_pointer_offset;
2424 +
2425 +  /* Offset of hard frame pointer from stack pointer/frame bottom */
2426 +  HOST_WIDE_INT hard_frame_pointer_offset;
2427 +
2428 +  /* The offset of arg_pointer_rtx from the bottom of the frame.  */
2429 +  HOST_WIDE_INT arg_pointer_offset;
2430 +};
2431 +
2432 +struct GTY(())  machine_function {
2433 +  /* The number of extra stack bytes taken up by register varargs.
2434 +     This area is allocated by the callee at the very top of the frame.  */
2435 +  int varargs_size;
2436 +
2437 +  /* The current frame information, calculated by mips_compute_frame_info.  */
2438 +  struct mips_frame_info frame;
2439 +};
2440 +
2441 +/* Information about a single argument.  */
2442 +struct mips_arg_info {
2443 +  /* True if the argument is passed in a floating-point register, or
2444 +     would have been if we hadn't run out of registers.  */
2445 +  bool fpr_p;
2446 +
2447 +  /* The number of words passed in registers, rounded up.  */
2448 +  unsigned int reg_words;
2449 +
2450 +  /* For EABI, the offset of the first register from GP_ARG_FIRST or
2451 +     FP_ARG_FIRST.  For other ABIs, the offset of the first register from
2452 +     the start of the ABI's argument structure (see the CUMULATIVE_ARGS
2453 +     comment for details).
2454 +
2455 +     The value is MAX_ARGS_IN_REGISTERS if the argument is passed entirely
2456 +     on the stack.  */
2457 +  unsigned int reg_offset;
2458 +
2459 +  /* The number of words that must be passed on the stack, rounded up.  */
2460 +  unsigned int stack_words;
2461 +
2462 +  /* The offset from the start of the stack overflow area of the argument's
2463 +     first stack word.  Only meaningful when STACK_WORDS is nonzero.  */
2464 +  unsigned int stack_offset;
2465 +};
2466 +
2467 +/* Information about an address described by mips_address_type.
2468 +
2469 +   ADDRESS_CONST_INT
2470 +       No fields are used.
2471 +
2472 +   ADDRESS_REG
2473 +       REG is the base register and OFFSET is the constant offset.
2474 +
2475 +   ADDRESS_LO_SUM
2476 +       REG and OFFSET are the operands to the LO_SUM and SYMBOL_TYPE
2477 +       is the type of symbol it references.
2478 +
2479 +   ADDRESS_SYMBOLIC
2480 +       SYMBOL_TYPE is the type of symbol that the address references.  */
2481 +struct mips_address_info {
2482 +  enum mips_address_type type;
2483 +  rtx reg;
2484 +  rtx offset;
2485 +  enum mips_symbol_type symbol_type;
2486 +};
2487 +
2488 +/* One stage in a constant building sequence.  These sequences have
2489 +   the form:
2490 +
2491 +       A = VALUE[0]
2492 +       A = A CODE[1] VALUE[1]
2493 +       A = A CODE[2] VALUE[2]
2494 +       ...
2495 +
2496 +   where A is an accumulator, each CODE[i] is a binary rtl operation
2497 +   and each VALUE[i] is a constant integer.  CODE[0] is undefined.  */
2498 +struct mips_integer_op {
2499 +  enum rtx_code code;
2500 +  unsigned HOST_WIDE_INT value;
2501 +};
2502 +
2503 +/* The largest number of operations needed to load an integer constant.
2504 +   The worst accepted case for 64-bit constants is LUI,ORI,SLL,ORI,SLL,ORI.
2505 +   When the lowest bit is clear, we can try, but reject a sequence with
2506 +   an extra SLL at the end.  */
2507 +#define MIPS_MAX_INTEGER_OPS 32
2508 +
2509 +/* Costs of various operations on the different architectures.  */
2510 +
2511 +struct mips_rtx_cost_data
2512 +{
2513 +  unsigned short fp_add;
2514 +  unsigned short fp_mult_sf;
2515 +  unsigned short fp_mult_df;
2516 +  unsigned short fp_div_sf;
2517 +  unsigned short fp_div_df;
2518 +  unsigned short int_mult_si;
2519 +  unsigned short int_mult_di;
2520 +  unsigned short int_div_si;
2521 +  unsigned short int_div_di;
2522 +  unsigned short branch_cost;
2523 +  unsigned short memory_latency;
2524 +};
2525 +
2526 +/* Global variables for machine-dependent things.  */
2527 +
2528 +/* The number of file directives written by mips_output_filename.  */
2529 +int num_source_filenames;
2530 +
2531 +/* The name that appeared in the last .file directive written by
2532 +   mips_output_filename, or "" if mips_output_filename hasn't
2533 +   written anything yet.  */
2534 +const char *current_function_file = "";
2535 +
2536 +/* Arrays that map GCC register numbers to debugger register numbers.  */
2537 +int mips_dbx_regno[FIRST_PSEUDO_REGISTER];
2538 +int mips_dwarf_regno[FIRST_PSEUDO_REGISTER];
2539 +
2540 +/* The processor that we should tune the code for.  */
2541 +enum processor mips_tune;
2542 +
2543 +/* Which cost information to use.  */
2544 +static const struct mips_rtx_cost_data *mips_cost;
2545 +
2546 +/* Index [M][R] is true if register R is allowed to hold a value of mode M.  */
2547 +bool mips_hard_regno_mode_ok[(int) MAX_MACHINE_MODE][FIRST_PSEUDO_REGISTER];
2548 +
2549 +static GTY (()) int mips_output_filename_first_time = 1;
2550 +
2551 +/* mips_split_p[X] is true if symbols of type X can be split by
2552 +   mips_split_symbol.  */
2553 +bool mips_split_p[NUM_SYMBOL_TYPES];
2554 +
2555 +/* mips_lo_relocs[X] is the relocation to use when a symbol of type X
2556 +   appears in a LO_SUM.  It can be null if such LO_SUMs aren't valid or
2557 +   if they are matched by a special .md file pattern.  */
2558 +static const char *mips_lo_relocs[NUM_SYMBOL_TYPES];
2559 +
2560 +/* Likewise for HIGHs.  */
2561 +static const char *mips_hi_relocs[NUM_SYMBOL_TYPES];
2562 +
2563 +/* Target state for MIPS16.  */
2564 +struct target_globals *mips16_globals;
2565 +
2566 +/* Index R is the smallest register class that contains register R.  */
2567 +const enum reg_class mips_regno_to_class[FIRST_PSEUDO_REGISTER] = {
2568 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
2569 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
2570 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
2571 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
2572 +  GR_REGS,     V1_REG,         GR_REGS,        GR_REGS,
2573 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
2574 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
2575 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
2576 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
2577 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
2578 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
2579 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
2580 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
2581 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
2582 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
2583 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
2584 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
2585 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
2586 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
2587 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
2588 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
2589 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
2590 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
2591 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
2592 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
2593 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
2594 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
2595 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
2596 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
2597 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
2598 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
2599 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
2600 +  FRAME_REGS,  FRAME_REGS,     NO_REGS,        NO_REGS,
2601 +};
2602 +
2603 +/* The value of TARGET_ATTRIBUTE_TABLE.  */
2604 +static const struct attribute_spec mips_attribute_table[] = {
2605 +  /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2606 +  { "long_call",   0, 0, false, true,  true,  NULL },
2607 +  { "far",                0, 0, false, true,  true,  NULL },
2608 +  { "near",        0, 0, false, true,  true,  NULL },
2609 +  { "utfunc",      0, 0, true,  false, false, NULL },
2610 +  { NULL,         0, 0, false, false, false, NULL }
2611 +};
2612 +\f
2613 +/* A table describing all the processors GCC knows about.  Names are
2614 +   matched in the order listed.  The first mention of an ISA level is
2615 +   taken as the canonical name for that ISA.
2616 +
2617 +   To ease comparison, please keep this table in the same order
2618 +   as GAS's mips_cpu_info_table.  Please also make sure that
2619 +   MIPS_ISA_LEVEL_SPEC and MIPS_ARCH_FLOAT_SPEC handle all -march
2620 +   options correctly.  */
2621 +static const struct mips_cpu_info mips_cpu_info_table[] = {
2622 +  /* Entries for generic ISAs.  */
2623 +  { "rocket", PROCESSOR_ROCKET, 0 },
2624 +};
2625 +
2626 +/* Default costs.  If these are used for a processor we should look
2627 +   up the actual costs.  */
2628 +#define DEFAULT_COSTS COSTS_N_INSNS (8),  /* fp_add */       \
2629 +                      COSTS_N_INSNS (8),  /* fp_mult_sf */   \
2630 +                      COSTS_N_INSNS (8),  /* fp_mult_df */   \
2631 +                      COSTS_N_INSNS (20), /* fp_div_sf */    \
2632 +                      COSTS_N_INSNS (20), /* fp_div_df */    \
2633 +                      COSTS_N_INSNS (10), /* int_mult_si */  \
2634 +                      COSTS_N_INSNS (10), /* int_mult_di */  \
2635 +                      COSTS_N_INSNS (69), /* int_div_si */   \
2636 +                      COSTS_N_INSNS (69), /* int_div_di */   \
2637 +                                       2, /* branch_cost */  \
2638 +                                       7  /* memory_latency */
2639 +
2640 +/* Floating-point costs for processors without an FPU.  Just assume that
2641 +   all floating-point libcalls are very expensive.  */
2642 +#define SOFT_FP_COSTS COSTS_N_INSNS (256), /* fp_add */       \
2643 +                      COSTS_N_INSNS (256), /* fp_mult_sf */   \
2644 +                      COSTS_N_INSNS (256), /* fp_mult_df */   \
2645 +                      COSTS_N_INSNS (256), /* fp_div_sf */    \
2646 +                      COSTS_N_INSNS (256)  /* fp_div_df */
2647 +
2648 +/* Costs to use when optimizing for size.  */
2649 +static const struct mips_rtx_cost_data mips_rtx_cost_optimize_size = {
2650 +  COSTS_N_INSNS (1),            /* fp_add */
2651 +  COSTS_N_INSNS (1),            /* fp_mult_sf */
2652 +  COSTS_N_INSNS (1),            /* fp_mult_df */
2653 +  COSTS_N_INSNS (1),            /* fp_div_sf */
2654 +  COSTS_N_INSNS (1),            /* fp_div_df */
2655 +  COSTS_N_INSNS (1),            /* int_mult_si */
2656 +  COSTS_N_INSNS (1),            /* int_mult_di */
2657 +  COSTS_N_INSNS (1),            /* int_div_si */
2658 +  COSTS_N_INSNS (1),            /* int_div_di */
2659 +                  2,           /* branch_cost */
2660 +                  4            /* memory_latency */
2661 +};
2662 +
2663 +/* Costs to use when optimizing for speed, indexed by processor.  */
2664 +static const struct mips_rtx_cost_data
2665 +  mips_rtx_cost_data[NUM_PROCESSOR_VALUES] = {
2666 +  { /* Rocket */ DEFAULT_COSTS},
2667 +};
2668 +\f
2669 +static int mips_register_move_cost (enum machine_mode, reg_class_t,
2670 +                                   reg_class_t);
2671 +static unsigned int mips_function_arg_boundary (enum machine_mode, const_tree);
2672 +
2673 +/* Predicates to test for presence of "near" and "far"/"long_call"
2674 +   attributes on the given TYPE.  */
2675 +
2676 +static bool
2677 +mips_near_type_p (const_tree type)
2678 +{
2679 +  return lookup_attribute ("near", TYPE_ATTRIBUTES (type)) != NULL;
2680 +}
2681 +
2682 +static bool
2683 +mips_far_type_p (const_tree type)
2684 +{
2685 +  return (lookup_attribute ("long_call", TYPE_ATTRIBUTES (type)) != NULL
2686 +         || lookup_attribute ("far", TYPE_ATTRIBUTES (type)) != NULL);
2687 +}
2688 +
2689 +/* Implement TARGET_COMP_TYPE_ATTRIBUTES.  */
2690 +
2691 +static int
2692 +mips_comp_type_attributes (const_tree type1, const_tree type2)
2693 +{
2694 +  /* Disallow mixed near/far attributes.  */
2695 +  if (mips_far_type_p (type1) && mips_near_type_p (type2))
2696 +    return 0;
2697 +  if (mips_near_type_p (type1) && mips_far_type_p (type2))
2698 +    return 0;
2699 +  return 1;
2700 +}
2701 +
2702 +/* If X is a PLUS of a CONST_INT, return the two terms in *BASE_PTR
2703 +   and *OFFSET_PTR.  Return X in *BASE_PTR and 0 in *OFFSET_PTR otherwise.  */
2704 +
2705 +static void
2706 +mips_split_plus (rtx x, rtx *base_ptr, HOST_WIDE_INT *offset_ptr)
2707 +{
2708 +  if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
2709 +    {
2710 +      *base_ptr = XEXP (x, 0);
2711 +      *offset_ptr = INTVAL (XEXP (x, 1));
2712 +    }
2713 +  else
2714 +    {
2715 +      *base_ptr = x;
2716 +      *offset_ptr = 0;
2717 +    }
2718 +}
2719 +
2720 +/* Fill CODES with a sequence of rtl operations to load VALUE.
2721 +   Return the number of operations needed.  */
2722 +
2723 +static int
2724 +riscv_build_integer_simple (struct mips_integer_op *codes, HOST_WIDE_INT value)
2725 +{
2726 +  HOST_WIDE_INT low_part = RISCV_CONST_LOW_PART (value);
2727 +  int cost = INT_MAX, alt_cost;
2728 +  struct mips_integer_op alt_codes[MIPS_MAX_INTEGER_OPS];
2729 +
2730 +  if (SMALL_OPERAND (value) || LUI_OPERAND (value))
2731 +    {
2732 +      /* Simply ADDI or LUI */
2733 +      codes[0].code = UNKNOWN;
2734 +      codes[0].value = value;
2735 +      return 1;
2736 +    }
2737 +
2738 +  /* End with ADDI */
2739 +  if (low_part != 0)
2740 +    {
2741 +      cost = 1 + riscv_build_integer_simple (codes, value - low_part);
2742 +      codes[cost-1].code = PLUS;
2743 +      codes[cost-1].value = low_part;
2744 +    }
2745 +
2746 +  /* End with XORI */
2747 +  if (low_part < 0)
2748 +    {
2749 +      alt_cost = 1 + riscv_build_integer_simple (alt_codes, value ^ low_part);
2750 +      alt_codes[alt_cost-1].code = XOR;
2751 +      alt_codes[alt_cost-1].value = low_part;
2752 +      if (alt_cost < cost)
2753 +       cost = alt_cost, memcpy (codes, alt_codes, sizeof(alt_codes));
2754 +    }
2755 +
2756 +  /* Eliminate trailing zeros and end with SLLI */
2757 +  if ((value & 1) == 0)
2758 +    {
2759 +      int shift = __builtin_ctzl(value);
2760 +      alt_cost = 1 + riscv_build_integer_simple (alt_codes, value >> shift);
2761 +      alt_codes[alt_cost-1].code = ASHIFT;
2762 +      alt_codes[alt_cost-1].value = shift;
2763 +      if (alt_cost < cost)
2764 +       cost = alt_cost, memcpy (codes, alt_codes, sizeof(alt_codes));
2765 +    }
2766 +
2767 +  gcc_assert (cost <= MIPS_MAX_INTEGER_OPS);
2768 +  return cost;
2769 +}
2770 +
2771 +static int
2772 +riscv_build_integer (struct mips_integer_op *codes, HOST_WIDE_INT value)
2773 +{
2774 +  int cost = riscv_build_integer_simple (codes, value);
2775 +
2776 +  /* Eliminate leading zeros and end with SRLI */
2777 +  if (value > 0 && cost > 2)
2778 +    {
2779 +      struct mips_integer_op alt_codes[MIPS_MAX_INTEGER_OPS];
2780 +      int alt_cost, shift;
2781 +
2782 +      shift = __builtin_clzl(value);
2783 +      alt_cost = 1 + riscv_build_integer_simple (alt_codes, value << shift);
2784 +      alt_codes[alt_cost-1].code = LSHIFTRT;
2785 +      alt_codes[alt_cost-1].value = shift;
2786 +      if (alt_cost < cost)
2787 +       cost = alt_cost, memcpy (codes, alt_codes, sizeof(alt_codes));
2788 +
2789 +      /* Also try filling discarded bits with 1s */
2790 +      shift = __builtin_clzl(value);
2791 +      alt_cost = 1 + riscv_build_integer_simple (alt_codes,
2792 +                       value << shift | ((1L<<shift)-1));
2793 +      alt_codes[alt_cost-1].code = LSHIFTRT;
2794 +      alt_codes[alt_cost-1].value = shift;
2795 +      if (alt_cost < cost)
2796 +       cost = alt_cost, memcpy (codes, alt_codes, sizeof(alt_codes));
2797 +    }
2798 +
2799 +  return cost;
2800 +}
2801 +
2802 +/* Return true if X is a thread-local symbol.  */
2803 +
2804 +static bool
2805 +mips_tls_symbol_p (const_rtx x)
2806 +{
2807 +  return GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (x) != 0;
2808 +}
2809 +
2810 +bool
2811 +riscv_symbol_binds_local_p (const_rtx x)
2812 +{
2813 +  if (SYMBOL_REF_DECL (x))
2814 +    {
2815 +      if (DECL_BUILT_IN_CLASS (SYMBOL_REF_DECL (x)))
2816 +       return true; /* Force local binding of memset etc. */
2817 +      return targetm.binds_local_p (SYMBOL_REF_DECL (x));
2818 +    }
2819 +  return SYMBOL_REF_LOCAL_P (x);
2820 +}
2821 +
2822 +/* Return the method that should be used to access SYMBOL_REF or
2823 +   LABEL_REF X in context CONTEXT.  */
2824 +
2825 +static enum mips_symbol_type
2826 +mips_classify_symbol (const_rtx x)
2827 +{
2828 +  if (mips_tls_symbol_p (x))
2829 +    return SYMBOL_TLS;
2830 +  return SYMBOL_ABSOLUTE;
2831 +}
2832 +
2833 +/* Classify the base of symbolic expression X, given that X appears in
2834 +   context CONTEXT.  */
2835 +
2836 +static enum mips_symbol_type
2837 +mips_classify_symbolic_expression (rtx x)
2838 +{
2839 +  rtx offset;
2840 +
2841 +  split_const (x, &x, &offset);
2842 +  if (UNSPEC_ADDRESS_P (x))
2843 +    return UNSPEC_ADDRESS_TYPE (x);
2844 +
2845 +  return mips_classify_symbol (x);
2846 +}
2847 +
2848 +/* Return true if OFFSET is within the range [0, ALIGN), where ALIGN
2849 +   is the alignment in bytes of SYMBOL_REF X.  */
2850 +
2851 +static bool
2852 +mips_offset_within_alignment_p (rtx x, HOST_WIDE_INT offset)
2853 +{
2854 +  HOST_WIDE_INT align;
2855 +
2856 +  align = SYMBOL_REF_DECL (x) ? DECL_ALIGN_UNIT (SYMBOL_REF_DECL (x)) : 1;
2857 +  return IN_RANGE (offset, 0, align - 1);
2858 +}
2859 +
2860 +/* Return true if X is a symbolic constant that can be used in context
2861 +   CONTEXT.  If it is, store the type of the symbol in *SYMBOL_TYPE.  */
2862 +
2863 +bool
2864 +mips_symbolic_constant_p (rtx x, enum mips_symbol_type *symbol_type)
2865 +{
2866 +  rtx offset;
2867 +
2868 +  split_const (x, &x, &offset);
2869 +  if (UNSPEC_ADDRESS_P (x))
2870 +    {
2871 +      *symbol_type = UNSPEC_ADDRESS_TYPE (x);
2872 +      x = UNSPEC_ADDRESS (x);
2873 +    }
2874 +  else if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
2875 +    *symbol_type = mips_classify_symbol (x);
2876 +  else
2877 +    return false;
2878 +
2879 +  if (offset == const0_rtx)
2880 +    return true;
2881 +
2882 +  if (flag_pic)
2883 +  /* Load the base address from the GOT, then add the offset. The offset
2884 +     calculation can usually be folded into the load or store instruction. */
2885 +    return false;
2886 +
2887 +  /* Check whether a nonzero offset is valid for the underlying
2888 +     relocations.  */
2889 +  switch (*symbol_type)
2890 +    {
2891 +    case SYMBOL_ABSOLUTE:
2892 +      /* If the target has 64-bit pointers and the object file only
2893 +        supports 32-bit symbols, the values of those symbols will be
2894 +        sign-extended.  In this case we can't allow an arbitrary offset
2895 +        in case the 32-bit value X + OFFSET has a different sign from X.  */
2896 +      return Pmode == SImode || offset_within_block_p (x, INTVAL (offset));
2897 +
2898 +    case SYMBOL_TPREL:
2899 +      /* There is no carry between the HI and LO REL relocations, so the
2900 +        offset is only valid if we know it won't lead to such a carry.  */
2901 +      return mips_offset_within_alignment_p (x, INTVAL (offset));
2902 +
2903 +    case SYMBOL_TLS:
2904 +      return false;
2905 +    }
2906 +  gcc_unreachable ();
2907 +}
2908 +\f
2909 +/* Like mips_symbol_insns, but treat extended MIPS16 instructions as a
2910 +   single instruction.  We rely on the fact that, in the worst case,
2911 +   all instructions involved in a MIPS16 address calculation are usually
2912 +   extended ones.  */
2913 +
2914 +static int
2915 +mips_symbol_insns (enum mips_symbol_type type, enum machine_mode mode)
2916 +{
2917 +  switch (type)
2918 +    {
2919 +    case SYMBOL_ABSOLUTE:
2920 +    case SYMBOL_TPREL:
2921 +      /* One of LUI or AUIPC, followed by one of ADDI, LD, or LW. */
2922 +      return 2;
2923 +
2924 +    case SYMBOL_TLS:
2925 +      /* We don't treat a bare TLS symbol as a constant.  */
2926 +      return 0;
2927 +    }
2928 +  gcc_unreachable ();
2929 +}
2930 +
2931 +/* A for_each_rtx callback.  Stop the search if *X references a
2932 +   thread-local symbol.  */
2933 +
2934 +static int
2935 +mips_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
2936 +{
2937 +  return mips_tls_symbol_p (*x);
2938 +}
2939 +
2940 +/* Implement TARGET_CANNOT_FORCE_CONST_MEM.  */
2941 +
2942 +static bool
2943 +mips_cannot_force_const_mem (rtx x)
2944 +{
2945 +  enum mips_symbol_type type;
2946 +  rtx base, offset;
2947 +
2948 +  /* There is no assembler syntax for expressing an address-sized
2949 +     high part.  */
2950 +  if (GET_CODE (x) == HIGH)
2951 +    return true;
2952 +
2953 +  /* As an optimization, reject constants that mips_legitimize_move
2954 +     can expand inline.
2955 +
2956 +     Suppose we have a multi-instruction sequence that loads constant C
2957 +     into register R.  If R does not get allocated a hard register, and
2958 +     R is used in an operand that allows both registers and memory
2959 +     references, reload will consider forcing C into memory and using
2960 +     one of the instruction's memory alternatives.  Returning false
2961 +     here will force it to use an input reload instead.  */
2962 +  if (CONST_INT_P (x) && LEGITIMATE_CONSTANT_P (x))
2963 +    return true;
2964 +
2965 +  split_const (x, &base, &offset);
2966 +  if (mips_symbolic_constant_p (base, &type))
2967 +    {
2968 +      /* The same optimization as for CONST_INT.  */
2969 +      if (SMALL_INT (offset) && mips_symbol_insns (type, MAX_MACHINE_MODE) > 0)
2970 +       return true;
2971 +    }
2972 +
2973 +  /* TLS symbols must be computed by mips_legitimize_move.  */
2974 +  if (for_each_rtx (&x, &mips_tls_symbol_ref_1, NULL))
2975 +    return true;
2976 +
2977 +  return false;
2978 +}
2979 +
2980 +/* Return true if register REGNO is a valid base register for mode MODE.
2981 +   STRICT_P is true if REG_OK_STRICT is in effect.  */
2982 +
2983 +int
2984 +mips_regno_mode_ok_for_base_p (int regno, enum machine_mode mode ATTRIBUTE_UNUSED,
2985 +                              bool strict_p)
2986 +{
2987 +  if (!HARD_REGISTER_NUM_P (regno))
2988 +    {
2989 +      if (!strict_p)
2990 +       return true;
2991 +      regno = reg_renumber[regno];
2992 +    }
2993 +
2994 +  /* These fake registers will be eliminated to either the stack or
2995 +     hard frame pointer, both of which are usually valid base registers.
2996 +     Reload deals with the cases where the eliminated form isn't valid.  */
2997 +  if (regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM)
2998 +    return true;
2999 +
3000 +  return GP_REG_P (regno);
3001 +}
3002 +
3003 +/* Return true if X is a valid base register for mode MODE.
3004 +   STRICT_P is true if REG_OK_STRICT is in effect.  */
3005 +
3006 +static bool
3007 +mips_valid_base_register_p (rtx x, enum machine_mode mode, bool strict_p)
3008 +{
3009 +  if (!strict_p && GET_CODE (x) == SUBREG)
3010 +    x = SUBREG_REG (x);
3011 +
3012 +  return (REG_P (x)
3013 +         && mips_regno_mode_ok_for_base_p (REGNO (x), mode, strict_p));
3014 +}
3015 +
3016 +/* Return true if, for every base register BASE_REG, (plus BASE_REG X)
3017 +   can address a value of mode MODE.  */
3018 +
3019 +static bool
3020 +mips_valid_offset_p (rtx x, enum machine_mode mode)
3021 +{
3022 +  /* Check that X is a signed 12-bit number.  */
3023 +  if (!const_arith_operand (x, Pmode))
3024 +    return false;
3025 +
3026 +  /* We may need to split multiword moves, so make sure that every word
3027 +     is accessible.  */
3028 +  if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
3029 +      && !SMALL_OPERAND (INTVAL (x) + GET_MODE_SIZE (mode) - UNITS_PER_WORD))
3030 +    return false;
3031 +
3032 +  return true;
3033 +}
3034 +
3035 +/* Return true if a LO_SUM can address a value of mode MODE when the
3036 +   LO_SUM symbol has type SYMBOL_TYPE.  */
3037 +
3038 +static bool
3039 +mips_valid_lo_sum_p (enum mips_symbol_type symbol_type, enum machine_mode mode)
3040 +{
3041 +  /* Check that symbols of type SYMBOL_TYPE can be used to access values
3042 +     of mode MODE.  */
3043 +  if (mips_symbol_insns (symbol_type, mode) == 0)
3044 +    return false;
3045 +
3046 +  /* Check that there is a known low-part relocation.  */
3047 +  if (mips_lo_relocs[symbol_type] == NULL)
3048 +    return false;
3049 +
3050 +  /* We may need to split multiword moves, so make sure that each word
3051 +     can be accessed without inducing a carry.  This is mainly needed
3052 +     for o64, which has historically only guaranteed 64-bit alignment
3053 +     for 128-bit types.  */
3054 +  if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
3055 +      && GET_MODE_BITSIZE (mode) > GET_MODE_ALIGNMENT (mode))
3056 +    return false;
3057 +
3058 +  return true;
3059 +}
3060 +
3061 +/* Return true if X is a valid address for machine mode MODE.  If it is,
3062 +   fill in INFO appropriately.  STRICT_P is true if REG_OK_STRICT is in
3063 +   effect.  */
3064 +
3065 +static bool
3066 +mips_classify_address (struct mips_address_info *info, rtx x,
3067 +                      enum machine_mode mode, bool strict_p)
3068 +{
3069 +  switch (GET_CODE (x))
3070 +    {
3071 +    case REG:
3072 +    case SUBREG:
3073 +      info->type = ADDRESS_REG;
3074 +      info->reg = x;
3075 +      info->offset = const0_rtx;
3076 +      return mips_valid_base_register_p (info->reg, mode, strict_p);
3077 +
3078 +    case PLUS:
3079 +      info->type = ADDRESS_REG;
3080 +      info->reg = XEXP (x, 0);
3081 +      info->offset = XEXP (x, 1);
3082 +      return (mips_valid_base_register_p (info->reg, mode, strict_p)
3083 +             && mips_valid_offset_p (info->offset, mode));
3084 +
3085 +    case LO_SUM:
3086 +      info->type = ADDRESS_LO_SUM;
3087 +      info->reg = XEXP (x, 0);
3088 +      info->offset = XEXP (x, 1);
3089 +      /* We have to trust the creator of the LO_SUM to do something vaguely
3090 +        sane.  Target-independent code that creates a LO_SUM should also
3091 +        create and verify the matching HIGH.  Target-independent code that
3092 +        adds an offset to a LO_SUM must prove that the offset will not
3093 +        induce a carry.  Failure to do either of these things would be
3094 +        a bug, and we are not required to check for it here.  The MIPS
3095 +        backend itself should only create LO_SUMs for valid symbolic
3096 +        constants, with the high part being either a HIGH or a copy
3097 +        of _gp. */
3098 +      info->symbol_type
3099 +       = mips_classify_symbolic_expression (info->offset);
3100 +      return (mips_valid_base_register_p (info->reg, mode, strict_p)
3101 +             && mips_valid_lo_sum_p (info->symbol_type, mode));
3102 +
3103 +    case CONST_INT:
3104 +      /* Small-integer addresses don't occur very often, but they
3105 +        are legitimate if $0 is a valid base register.  */
3106 +      info->type = ADDRESS_CONST_INT;
3107 +      return SMALL_INT (x);
3108 +
3109 +    case CONST:
3110 +    case LABEL_REF:
3111 +    case SYMBOL_REF:
3112 +      info->type = ADDRESS_SYMBOLIC;
3113 +      return false;
3114 +
3115 +    default:
3116 +      return false;
3117 +    }
3118 +}
3119 +
3120 +/* Implement TARGET_LEGITIMATE_ADDRESS_P.  */
3121 +
3122 +static bool
3123 +mips_legitimate_address_p (enum machine_mode mode, rtx x, bool strict_p)
3124 +{
3125 +  struct mips_address_info addr;
3126 +
3127 +  return mips_classify_address (&addr, x, mode, strict_p);
3128 +}
3129 +
3130 +/* Return the number of instructions needed to load or store a value
3131 +   of mode MODE at address X.  Return 0 if X isn't valid for MODE.
3132 +   Assume that multiword moves may need to be split into word moves
3133 +   if MIGHT_SPLIT_P, otherwise assume that a single load or store is
3134 +   enough.
3135 +
3136 +   For MIPS16 code, count extended instructions as two instructions.  */
3137 +
3138 +int
3139 +mips_address_insns (rtx x, enum machine_mode mode, bool might_split_p)
3140 +{
3141 +  struct mips_address_info addr;
3142 +
3143 +  if (mips_classify_address (&addr, x, mode, false))
3144 +    {
3145 +      int factor = 1;
3146 +
3147 +      /* BLKmode is used for single unaligned loads and stores and should
3148 +         not count as a multiword mode. */
3149 +      if (mode != BLKmode && might_split_p)
3150 +        factor = (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3151 +
3152 +      if (addr.type == ADDRESS_SYMBOLIC)
3153 +       factor *= mips_symbol_insns (addr.symbol_type, mode);
3154 +
3155 +      return factor;
3156 +    }
3157 +
3158 +  return 0;
3159 +}
3160 +
3161 +/* Return the number of instructions needed to load constant X.
3162 +   Return 0 if X isn't a valid constant.  */
3163 +
3164 +int
3165 +mips_const_insns (rtx x)
3166 +{
3167 +  struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
3168 +  enum mips_symbol_type symbol_type;
3169 +  rtx offset;
3170 +
3171 +  switch (GET_CODE (x))
3172 +    {
3173 +    case HIGH:
3174 +      if (!mips_symbolic_constant_p (XEXP (x, 0), &symbol_type)
3175 +         || !mips_split_p[symbol_type])
3176 +       return 0;
3177 +
3178 +      /* This is simply an LUI. */
3179 +      return 1;
3180 +
3181 +    case CONST_INT:
3182 +      return riscv_build_integer (codes, INTVAL (x));
3183 +
3184 +    case CONST_DOUBLE:
3185 +    case CONST_VECTOR:
3186 +      /* Allow zeros for normal mode, where we can use $0.  */
3187 +      return x == CONST0_RTX (GET_MODE (x)) ? 1 : 0;
3188 +
3189 +    case CONST:
3190 +      /* See if we can refer to X directly.  */
3191 +      if (mips_symbolic_constant_p (x, &symbol_type))
3192 +       return mips_symbol_insns (symbol_type, MAX_MACHINE_MODE);
3193 +
3194 +      /* Otherwise try splitting the constant into a base and offset.
3195 +        If the offset is a 16-bit value, we can load the base address
3196 +        into a register and then use (D)ADDIU to add in the offset.
3197 +        If the offset is larger, we can load the base and offset
3198 +        into separate registers and add them together with (D)ADDU.
3199 +        However, the latter is only possible before reload; during
3200 +        and after reload, we must have the option of forcing the
3201 +        constant into the pool instead.  */
3202 +      split_const (x, &x, &offset);
3203 +      if (offset != 0)
3204 +       {
3205 +         int n = mips_const_insns (x);
3206 +         if (n != 0)
3207 +           {
3208 +             if (SMALL_INT (offset))
3209 +               return n + 1;
3210 +             else if (!targetm.cannot_force_const_mem (x))
3211 +               return n + 1 + riscv_build_integer (codes, INTVAL (offset));
3212 +           }
3213 +       }
3214 +      return 0;
3215 +
3216 +    case SYMBOL_REF:
3217 +    case LABEL_REF:
3218 +      return mips_symbol_insns (mips_classify_symbol (x), MAX_MACHINE_MODE);
3219 +
3220 +    default:
3221 +      return 0;
3222 +    }
3223 +}
3224 +
3225 +/* X is a doubleword constant that can be handled by splitting it into
3226 +   two words and loading each word separately.  Return the number of
3227 +   instructions required to do this.  */
3228 +
3229 +int
3230 +mips_split_const_insns (rtx x)
3231 +{
3232 +  unsigned int low, high;
3233 +
3234 +  low = mips_const_insns (mips_subword (x, false));
3235 +  high = mips_const_insns (mips_subword (x, true));
3236 +  gcc_assert (low > 0 && high > 0);
3237 +  return low + high;
3238 +}
3239 +
3240 +/* Return the number of instructions needed to implement INSN,
3241 +   given that it loads from or stores to MEM.  Count extended
3242 +   MIPS16 instructions as two instructions.  */
3243 +
3244 +int
3245 +mips_load_store_insns (rtx mem, rtx insn)
3246 +{
3247 +  enum machine_mode mode;
3248 +  bool might_split_p;
3249 +  rtx set;
3250 +
3251 +  gcc_assert (MEM_P (mem));
3252 +  mode = GET_MODE (mem);
3253 +
3254 +  /* Try to prove that INSN does not need to be split.  */
3255 +  might_split_p = true;
3256 +  if (GET_MODE_BITSIZE (mode) == 64)
3257 +    {
3258 +      set = single_set (insn);
3259 +      if (set && !mips_split_64bit_move_p (SET_DEST (set), SET_SRC (set)))
3260 +       might_split_p = false;
3261 +    }
3262 +
3263 +  return mips_address_insns (XEXP (mem, 0), mode, might_split_p);
3264 +}
3265 +
3266 +/* Emit a move from SRC to DEST.  Assume that the move expanders can
3267 +   handle all moves if !can_create_pseudo_p ().  The distinction is
3268 +   important because, unlike emit_move_insn, the move expanders know
3269 +   how to force Pmode objects into the constant pool even when the
3270 +   constant pool address is not itself legitimate.  */
3271 +
3272 +rtx
3273 +mips_emit_move (rtx dest, rtx src)
3274 +{
3275 +  return (can_create_pseudo_p ()
3276 +         ? emit_move_insn (dest, src)
3277 +         : emit_move_insn_1 (dest, src));
3278 +}
3279 +
3280 +/* Emit an instruction of the form (set TARGET (CODE OP0 OP1)).  */
3281 +
3282 +static void
3283 +mips_emit_binary (enum rtx_code code, rtx target, rtx op0, rtx op1)
3284 +{
3285 +  emit_insn (gen_rtx_SET (VOIDmode, target,
3286 +                         gen_rtx_fmt_ee (code, GET_MODE (target), op0, op1)));
3287 +}
3288 +
3289 +/* Compute (CODE OP0 OP1) and store the result in a new register
3290 +   of mode MODE.  Return that new register.  */
3291 +
3292 +static rtx
3293 +mips_force_binary (enum machine_mode mode, enum rtx_code code, rtx op0, rtx op1)
3294 +{
3295 +  rtx reg;
3296 +
3297 +  reg = gen_reg_rtx (mode);
3298 +  mips_emit_binary (code, reg, op0, op1);
3299 +  return reg;
3300 +}
3301 +
3302 +/* Copy VALUE to a register and return that register.  If new pseudos
3303 +   are allowed, copy it into a new register, otherwise use DEST.  */
3304 +
3305 +static rtx
3306 +mips_force_temporary (rtx dest, rtx value)
3307 +{
3308 +  if (can_create_pseudo_p ())
3309 +    return force_reg (Pmode, value);
3310 +  else
3311 +    {
3312 +      mips_emit_move (dest, value);
3313 +      return dest;
3314 +    }
3315 +}
3316 +
3317 +/* Wrap symbol or label BASE in an UNSPEC address of type SYMBOL_TYPE,
3318 +   then add CONST_INT OFFSET to the result.  */
3319 +
3320 +static rtx
3321 +mips_unspec_address_offset (rtx base, rtx offset,
3322 +                           enum mips_symbol_type symbol_type)
3323 +{
3324 +  base = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, base),
3325 +                        UNSPEC_ADDRESS_FIRST + symbol_type);
3326 +  if (offset != const0_rtx)
3327 +    base = gen_rtx_PLUS (Pmode, base, offset);
3328 +  return gen_rtx_CONST (Pmode, base);
3329 +}
3330 +
3331 +/* Return an UNSPEC address with underlying address ADDRESS and symbol
3332 +   type SYMBOL_TYPE.  */
3333 +
3334 +rtx
3335 +mips_unspec_address (rtx address, enum mips_symbol_type symbol_type)
3336 +{
3337 +  rtx base, offset;
3338 +
3339 +  split_const (address, &base, &offset);
3340 +  return mips_unspec_address_offset (base, offset, symbol_type);
3341 +}
3342 +
3343 +/* If OP is an UNSPEC address, return the address to which it refers,
3344 +   otherwise return OP itself.  */
3345 +
3346 +static rtx
3347 +mips_strip_unspec_address (rtx op)
3348 +{
3349 +  rtx base, offset;
3350 +
3351 +  split_const (op, &base, &offset);
3352 +  if (UNSPEC_ADDRESS_P (base))
3353 +    op = plus_constant (UNSPEC_ADDRESS (base), INTVAL (offset));
3354 +  return op;
3355 +}
3356 +
3357 +/* If mips_unspec_address (ADDR, SYMBOL_TYPE) is a 32-bit value, add the
3358 +   high part to BASE and return the result.  Just return BASE otherwise.
3359 +   TEMP is as for mips_force_temporary.
3360 +
3361 +   The returned expression can be used as the first operand to a LO_SUM.  */
3362 +
3363 +static rtx
3364 +mips_unspec_offset_high (rtx temp, rtx base, rtx addr,
3365 +                        enum mips_symbol_type symbol_type)
3366 +{
3367 +  if (mips_split_p[symbol_type])
3368 +    {
3369 +      addr = gen_rtx_HIGH (Pmode, mips_unspec_address (addr, symbol_type));
3370 +      addr = mips_force_temporary (temp, addr);
3371 +      base = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, addr, base));
3372 +    }
3373 +  return base;
3374 +}
3375 +
3376 +/* If MODE is MAX_MACHINE_MODE, ADDR appears as a move operand, otherwise
3377 +   it appears in a MEM of that mode.  Return true if ADDR is a legitimate
3378 +   constant in that context and can be split into high and low parts.
3379 +   If so, and if LOW_OUT is nonnull, emit the high part and store the
3380 +   low part in *LOW_OUT.  Leave *LOW_OUT unchanged otherwise.
3381 +
3382 +   TEMP is as for mips_force_temporary and is used to load the high
3383 +   part into a register.
3384 +
3385 +   When MODE is MAX_MACHINE_MODE, the low part is guaranteed to be
3386 +   a legitimize SET_SRC for an .md pattern, otherwise the low part
3387 +   is guaranteed to be a legitimate address for mode MODE.  */
3388 +
3389 +bool
3390 +mips_split_symbol (rtx temp, rtx addr, enum machine_mode mode, rtx *low_out)
3391 +{
3392 +  enum mips_symbol_type symbol_type;
3393 +  rtx high;
3394 +
3395 +  if (!(GET_CODE (addr) == HIGH && mode == MAX_MACHINE_MODE))
3396 +    {
3397 +      if (mips_symbolic_constant_p (addr, &symbol_type)
3398 +         && mips_symbol_insns (symbol_type, mode) > 0
3399 +         && mips_split_p[symbol_type])
3400 +       {
3401 +         if (low_out)
3402 +           {
3403 +             high = gen_rtx_HIGH (Pmode, copy_rtx (addr));
3404 +             high = mips_force_temporary (temp, high);
3405 +             *low_out = gen_rtx_LO_SUM (Pmode, high, addr);
3406 +           }
3407 +         return true;
3408 +       }
3409 +    }
3410 +  return false;
3411 +}
3412 +
3413 +/* Return a legitimate address for REG + OFFSET.  TEMP is as for
3414 +   mips_force_temporary; it is only needed when OFFSET is not a
3415 +   SMALL_OPERAND.  */
3416 +
3417 +static rtx
3418 +mips_add_offset (rtx temp, rtx reg, HOST_WIDE_INT offset)
3419 +{
3420 +  if (!SMALL_OPERAND (offset))
3421 +    {
3422 +      rtx high;
3423 +
3424 +      /* Leave OFFSET as a 16-bit offset and put the excess in HIGH.
3425 +         The addition inside the macro CONST_HIGH_PART may cause an
3426 +         overflow, so we need to force a sign-extension check.  */
3427 +      high = gen_int_mode (RISCV_CONST_HIGH_PART (offset), Pmode);
3428 +      offset = RISCV_CONST_LOW_PART (offset);
3429 +      high = mips_force_temporary (temp, high);
3430 +      reg = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, high, reg));
3431 +    }
3432 +  return plus_constant (reg, offset);
3433 +}
3434 +
3435 +/* Load an entry from the GOT. */
3436 +static rtx riscv_got_load(rtx dest, rtx sym)
3437 +{
3438 +  return (Pmode == DImode ? gen_got_loaddi(dest, sym) : gen_got_loadsi(dest, sym));
3439 +}
3440 +static rtx riscv_got_load_tls_gd(rtx dest, rtx sym)
3441 +{
3442 +  return (Pmode == DImode ? gen_got_load_tls_gddi(dest, sym) : gen_got_load_tls_gdsi(dest, sym));
3443 +}
3444 +static rtx riscv_got_load_tls_ie(rtx dest, rtx sym)
3445 +{
3446 +  return (Pmode == DImode ? gen_got_load_tls_iedi(dest, sym) : gen_got_load_tls_iesi(dest, sym));
3447 +}
3448 +
3449 +/* The __tls_get_attr symbol.  */
3450 +static GTY(()) rtx mips_tls_symbol;
3451 +
3452 +/* Return an instruction sequence that calls __tls_get_addr.  SYM is
3453 +   the TLS symbol we are referencing and TYPE is the symbol type to use
3454 +   (either global dynamic or local dynamic).  V0 is an RTX for the
3455 +   return value location.  */
3456 +
3457 +static rtx
3458 +mips_call_tls_get_addr (rtx sym, rtx v0)
3459 +{
3460 +  rtx insn, a0;
3461 +
3462 +  a0 = gen_rtx_REG (Pmode, GP_ARG_FIRST);
3463 +
3464 +  if (!mips_tls_symbol)
3465 +    mips_tls_symbol = init_one_libfunc ("__tls_get_addr");
3466 +
3467 +  start_sequence ();
3468 +  
3469 +  emit_insn (riscv_got_load_tls_gd(a0, sym));
3470 +  insn = mips_expand_call (false, v0, mips_tls_symbol, const0_rtx);
3471 +  RTL_CONST_CALL_P (insn) = 1;
3472 +  use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0);
3473 +  insn = get_insns ();
3474 +
3475 +  end_sequence ();
3476 +
3477 +  return insn;
3478 +}
3479 +
3480 +/* Generate the code to access LOC, a thread-local SYMBOL_REF, and return
3481 +   its address.  The return value will be both a valid address and a valid
3482 +   SET_SRC (either a REG or a LO_SUM).  */
3483 +
3484 +static rtx
3485 +mips_legitimize_tls_address (rtx loc)
3486 +{
3487 +  rtx dest, insn, v0, tp, tmp1;
3488 +  enum tls_model model;
3489 +
3490 +  model = SYMBOL_REF_TLS_MODEL (loc);
3491 +  /* Only TARGET_ABICALLS code can have more than one module; other
3492 +     code must be be static and should not use a GOT.  All TLS models
3493 +     reduce to local exec in this situation.  */
3494 +  if (!TARGET_ABICALLS)
3495 +    model = TLS_MODEL_LOCAL_EXEC;
3496 +
3497 +  switch (model)
3498 +    {
3499 +    case TLS_MODEL_LOCAL_DYNAMIC:
3500 +      /* We don't support LDM TLS, so fall through.*/
3501 +    case TLS_MODEL_GLOBAL_DYNAMIC:
3502 +      v0 = gen_rtx_REG (Pmode, GP_RETURN);
3503 +      insn = mips_call_tls_get_addr (loc, v0);
3504 +      dest = gen_reg_rtx (Pmode);
3505 +      emit_libcall_block (insn, dest, v0, loc);
3506 +      break;
3507 +
3508 +    case TLS_MODEL_INITIAL_EXEC:
3509 +      tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM);
3510 +      tmp1 = gen_reg_rtx (Pmode);
3511 +      emit_insn (riscv_got_load_tls_ie(tmp1, loc));
3512 +      dest = gen_reg_rtx (Pmode);
3513 +      emit_insn (gen_add3_insn (dest, tmp1, tp));
3514 +      break;
3515 +
3516 +    case TLS_MODEL_LOCAL_EXEC:
3517 +      tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM);
3518 +      tmp1 = mips_unspec_offset_high (NULL, tp, loc, SYMBOL_TPREL);
3519 +      dest = gen_rtx_LO_SUM (Pmode, tmp1,
3520 +                            mips_unspec_address (loc, SYMBOL_TPREL));
3521 +      break;
3522 +
3523 +    default:
3524 +      gcc_unreachable ();
3525 +    }
3526 +  return dest;
3527 +}
3528 +\f
3529 +/* If X is not a valid address for mode MODE, force it into a register.  */
3530 +
3531 +static rtx
3532 +mips_force_address (rtx x, enum machine_mode mode)
3533 +{
3534 +  if (!mips_legitimate_address_p (mode, x, false))
3535 +    x = force_reg (Pmode, x);
3536 +  return x;
3537 +}
3538 +
3539 +/* This function is used to implement LEGITIMIZE_ADDRESS.  If X can
3540 +   be legitimized in a way that the generic machinery might not expect,
3541 +   return a new address, otherwise return NULL.  MODE is the mode of
3542 +   the memory being accessed.  */
3543 +
3544 +static rtx
3545 +mips_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3546 +                        enum machine_mode mode)
3547 +{
3548 +  rtx addr;
3549 +
3550 +  if (mips_tls_symbol_p (x))
3551 +    return mips_legitimize_tls_address (x);
3552 +
3553 +  /* See if the address can split into a high part and a LO_SUM.  */
3554 +  if (mips_split_symbol (NULL, x, mode, &addr))
3555 +    return mips_force_address (addr, mode);
3556 +
3557 +  /* Handle BASE + OFFSET using mips_add_offset.  */
3558 +  if (GET_CODE (x) == PLUS && CONST_INT_P (XEXP (x, 1))
3559 +      && INTVAL (XEXP (x, 1)) != 0)
3560 +    {
3561 +      rtx base = XEXP (x, 0);
3562 +      HOST_WIDE_INT offset = INTVAL (XEXP (x, 1));
3563 +
3564 +      if (!mips_valid_base_register_p (base, mode, false))
3565 +       base = copy_to_mode_reg (Pmode, base);
3566 +      addr = mips_add_offset (NULL, base, offset);
3567 +      return mips_force_address (addr, mode);
3568 +    }
3569 +
3570 +  return x;
3571 +}
3572 +
3573 +static int
3574 +riscv_split_integer_cost (HOST_WIDE_INT val)
3575 +{
3576 +  int cost = 0;
3577 +  struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
3578 +  int32_t loval = val, hival = (val - (int32_t)val) >> 32;
3579 +
3580 +  cost += riscv_build_integer(codes, loval);
3581 +  if (loval != hival)
3582 +    cost += riscv_build_integer(codes, hival);
3583 +  return cost + 2;
3584 +}
3585 +
3586 +/* Try to split a 64b integer into 32b parts, then reassemble. */
3587 +
3588 +static rtx
3589 +riscv_split_integer (HOST_WIDE_INT val, enum machine_mode mode)
3590 +{
3591 +  int32_t loval = val, hival = (val - (int32_t)val) >> 32;
3592 +  rtx hi = gen_reg_rtx (mode), lo = gen_reg_rtx (mode);
3593 +
3594 +  mips_move_integer (hi, hi, hival);
3595 +  mips_move_integer (lo, lo, loval);
3596 +
3597 +  hi = gen_rtx_fmt_ee (ASHIFT, mode, hi, GEN_INT (32));
3598 +  hi = force_reg (mode, hi);
3599 +
3600 +  return gen_rtx_fmt_ee (PLUS, mode, hi, lo);
3601 +}
3602 +
3603 +/* Load VALUE into DEST.  TEMP is as for mips_force_temporary.  */
3604 +
3605 +void
3606 +mips_move_integer (rtx temp, rtx dest, HOST_WIDE_INT value)
3607 +{
3608 +  struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
3609 +  enum machine_mode mode;
3610 +  unsigned int i, num_ops;
3611 +  rtx x;
3612 +
3613 +  mode = GET_MODE (dest);
3614 +  num_ops = riscv_build_integer (codes, value);
3615 +
3616 +  if (can_create_pseudo_p () && num_ops >= riscv_split_integer_cost (value))
3617 +    x = riscv_split_integer (value, mode);
3618 +  else
3619 +    {
3620 +      /* Apply each binary operation to X. */
3621 +      x = GEN_INT (codes[0].value);
3622 +
3623 +      for (i = 1; i < num_ops; i++)
3624 +        {
3625 +          if (!can_create_pseudo_p ())
3626 +            {
3627 +              emit_insn (gen_rtx_SET (VOIDmode, temp, x));
3628 +              x = temp;
3629 +            }
3630 +          else
3631 +            x = force_reg (mode == HImode ? SImode : mode, x);
3632 +
3633 +          x = gen_rtx_fmt_ee (codes[i].code, mode, x, GEN_INT (codes[i].value));
3634 +        }
3635 +    }
3636 +
3637 +  emit_insn (gen_rtx_SET (VOIDmode, dest, x));
3638 +}
3639 +
3640 +/* Subroutine of mips_legitimize_move.  Move constant SRC into register
3641 +   DEST given that SRC satisfies immediate_operand but doesn't satisfy
3642 +   move_operand.  */
3643 +
3644 +static void
3645 +mips_legitimize_const_move (enum machine_mode mode, rtx dest, rtx src)
3646 +{
3647 +  rtx base, offset;
3648 +
3649 +  /* Split moves of big integers into smaller pieces.  */
3650 +  if (splittable_const_int_operand (src, mode))
3651 +    {
3652 +      mips_move_integer (dest, dest, INTVAL (src));
3653 +      return;
3654 +    }
3655 +
3656 +  /* Split moves of symbolic constants into high/low pairs.  */
3657 +  if (mips_split_symbol (dest, src, MAX_MACHINE_MODE, &src))
3658 +    {
3659 +      emit_insn (gen_rtx_SET (VOIDmode, dest, src));
3660 +      return;
3661 +    }
3662 +
3663 +  /* Generate the appropriate access sequences for TLS symbols.  */
3664 +  if (mips_tls_symbol_p (src))
3665 +    {
3666 +      mips_emit_move (dest, mips_legitimize_tls_address (src));
3667 +      return;
3668 +    }
3669 +
3670 +  /* If we have (const (plus symbol offset)), and that expression cannot
3671 +     be forced into memory, load the symbol first and add in the offset.
3672 +     In non-MIPS16 mode, prefer to do this even if the constant _can_ be
3673 +     forced into memory, as it usually produces better code.  */
3674 +  split_const (src, &base, &offset);
3675 +  if (offset != const0_rtx
3676 +      && (targetm.cannot_force_const_mem (src)
3677 +         || can_create_pseudo_p ()))
3678 +    {
3679 +      base = mips_force_temporary (dest, base);
3680 +      mips_emit_move (dest, mips_add_offset (NULL, base, INTVAL (offset)));
3681 +      return;
3682 +    }
3683 +
3684 +  src = force_const_mem (mode, src);
3685 +
3686 +  /* When using explicit relocs, constant pool references are sometimes
3687 +     not legitimate addresses.  */
3688 +  mips_split_symbol (dest, XEXP (src, 0), mode, &XEXP (src, 0));
3689 +  mips_emit_move (dest, src);
3690 +}
3691 +
3692 +/* If (set DEST SRC) is not a valid move instruction, emit an equivalent
3693 +   sequence that is valid.  */
3694 +
3695 +bool
3696 +mips_legitimize_move (enum machine_mode mode, rtx dest, rtx src)
3697 +{
3698 +  if (!register_operand (dest, mode) && !reg_or_0_operand (src, mode))
3699 +    {
3700 +      mips_emit_move (dest, force_reg (mode, src));
3701 +      return true;
3702 +    }
3703 +
3704 +  /* We need to deal with constants that would be legitimate
3705 +     immediate_operands but aren't legitimate move_operands.  */
3706 +  if (CONSTANT_P (src) && !move_operand (src, mode))
3707 +    {
3708 +      mips_legitimize_const_move (mode, dest, src);
3709 +      set_unique_reg_note (get_last_insn (), REG_EQUAL, copy_rtx (src));
3710 +      return true;
3711 +    }
3712 +  return false;
3713 +}
3714 +
3715 +bool
3716 +mips_legitimize_vector_move (enum machine_mode mode, rtx dest, rtx src)
3717 +{
3718 +  bool dest_mem, dest_mem_reg;
3719 +  bool src_mem, src_mem_reg;
3720 +
3721 +  dest_mem = (GET_CODE(dest) == MEM);
3722 +  dest_mem_reg = dest_mem && GET_CODE(XEXP(dest, 0)) == REG;
3723 +
3724 +  src_mem = (GET_CODE(src) == MEM);
3725 +  src_mem_reg = src_mem && GET_CODE(XEXP(src, 0)) == REG;
3726 +
3727 +  if (dest_mem && !dest_mem_reg)
3728 +  {
3729 +    rtx add, scratch, base, move;
3730 +    HOST_WIDE_INT offset;
3731 +
3732 +    mips_split_plus(XEXP(dest,0), &base, &offset);
3733 +
3734 +    scratch = gen_reg_rtx(Pmode);
3735 +    add = gen_add3_insn(scratch, base, GEN_INT(offset));
3736 +    emit_insn(add);
3737 +
3738 +    switch (mode)
3739 +    {
3740 +      case MIPS_RISCV_VECTOR_MODE_NAME(DI):
3741 +        move = gen_movv32di(gen_rtx_MEM(mode, scratch), src);
3742 +        break;
3743 +      case MIPS_RISCV_VECTOR_MODE_NAME(SI):
3744 +        move = gen_movv32si(gen_rtx_MEM(mode, scratch), src);
3745 +        break;
3746 +      case MIPS_RISCV_VECTOR_MODE_NAME(HI):
3747 +        move = gen_movv32hi(gen_rtx_MEM(mode, scratch), src);
3748 +        break;
3749 +      case MIPS_RISCV_VECTOR_MODE_NAME(QI):
3750 +        move = gen_movv32qi(gen_rtx_MEM(mode, scratch), src);
3751 +        break;
3752 +      case MIPS_RISCV_VECTOR_MODE_NAME(DF):
3753 +        move = gen_movv32df(gen_rtx_MEM(mode, scratch), src);
3754 +        break;
3755 +      case MIPS_RISCV_VECTOR_MODE_NAME(SF):
3756 +        move = gen_movv32sf(gen_rtx_MEM(mode, scratch), src);
3757 +        break;
3758 +      default:
3759 +        gcc_unreachable();
3760 +    }
3761 +
3762 +    emit_insn(move);
3763 +
3764 +    return true;
3765 +  }
3766 +
3767 +  if (src_mem && !src_mem_reg)
3768 +  {
3769 +    rtx add, scratch, base, move;
3770 +    HOST_WIDE_INT offset;
3771 +
3772 +    mips_split_plus(XEXP(src,0), &base, &offset);
3773 +
3774 +    scratch = gen_reg_rtx(Pmode);
3775 +    add = gen_add3_insn(scratch, base, GEN_INT(offset));
3776 +    emit_insn(add);
3777 +
3778 +    switch (mode)
3779 +    {
3780 +      case MIPS_RISCV_VECTOR_MODE_NAME(DI):
3781 +        move = gen_movv32di(dest, gen_rtx_MEM(mode, scratch));
3782 +        break;
3783 +      case MIPS_RISCV_VECTOR_MODE_NAME(SI):
3784 +        move = gen_movv32si(dest, gen_rtx_MEM(mode, scratch));
3785 +        break;
3786 +      case MIPS_RISCV_VECTOR_MODE_NAME(HI):
3787 +        move = gen_movv32hi(dest, gen_rtx_MEM(mode, scratch));
3788 +        break;
3789 +      case MIPS_RISCV_VECTOR_MODE_NAME(QI):
3790 +        move = gen_movv32qi(dest, gen_rtx_MEM(mode, scratch));
3791 +        break;
3792 +      case MIPS_RISCV_VECTOR_MODE_NAME(DF):
3793 +        move = gen_movv32df(dest, gen_rtx_MEM(mode, scratch));
3794 +        break;
3795 +      case MIPS_RISCV_VECTOR_MODE_NAME(SF):
3796 +        move = gen_movv32sf(dest, gen_rtx_MEM(mode, scratch));
3797 +        break;
3798 +      default:
3799 +        gcc_unreachable();
3800 +    }
3801 +
3802 +    emit_insn(move);
3803 +
3804 +    return true;
3805 +  }
3806 +
3807 +  return false;
3808 +}
3809 +
3810 +/* The cost of loading values from the constant pool.  It should be
3811 +   larger than the cost of any constant we want to synthesize inline.  */
3812 +#define CONSTANT_POOL_COST COSTS_N_INSNS (8)
3813 +
3814 +/* Return true if there is a non-MIPS16 instruction that implements CODE
3815 +   and if that instruction accepts X as an immediate operand.  */
3816 +
3817 +static int
3818 +mips_immediate_operand_p (int code, HOST_WIDE_INT x)
3819 +{
3820 +  switch (code)
3821 +    {
3822 +    case ASHIFT:
3823 +    case ASHIFTRT:
3824 +    case LSHIFTRT:
3825 +      /* All shift counts are truncated to a valid constant.  */
3826 +      return true;
3827 +
3828 +    case AND:
3829 +    case IOR:
3830 +    case XOR:
3831 +    case PLUS:
3832 +    case LT:
3833 +    case LTU:
3834 +      /* These instructions take 12-bit signed immediates.  */
3835 +      return SMALL_OPERAND (x);
3836 +
3837 +    case LE:
3838 +      /* We add 1 to the immediate and use SLT.  */
3839 +      return SMALL_OPERAND (x + 1);
3840 +
3841 +    case LEU:
3842 +      /* Likewise SLTU, but reject the always-true case.  */
3843 +      return SMALL_OPERAND (x + 1) && x + 1 != 0;
3844 +
3845 +    case GE:
3846 +    case GEU:
3847 +      /* We can emulate an immediate of 1 by using GT/GTU against x0. */
3848 +      return x == 1;
3849 +
3850 +    default:
3851 +      /* By default assume that x0 can be used for 0.  */
3852 +      return x == 0;
3853 +    }
3854 +}
3855 +
3856 +/* Return the cost of binary operation X, given that the instruction
3857 +   sequence for a word-sized or smaller operation has cost SINGLE_COST
3858 +   and that the sequence of a double-word operation has cost DOUBLE_COST.
3859 +   If SPEED is true, optimize for speed otherwise optimize for size.  */
3860 +
3861 +static int
3862 +mips_binary_cost (rtx x, int single_cost, int double_cost, bool speed)
3863 +{
3864 +  if (GET_MODE_SIZE (GET_MODE (x)) == UNITS_PER_WORD * 2)
3865 +    single_cost = double_cost;
3866 +
3867 +  return (single_cost
3868 +         + rtx_cost (XEXP (x, 0), SET, speed)
3869 +         + rtx_cost (XEXP (x, 1), GET_CODE (x), speed));
3870 +}
3871 +
3872 +/* Return the cost of floating-point multiplications of mode MODE.  */
3873 +
3874 +static int
3875 +mips_fp_mult_cost (enum machine_mode mode)
3876 +{
3877 +  return mode == DFmode ? mips_cost->fp_mult_df : mips_cost->fp_mult_sf;
3878 +}
3879 +
3880 +/* Return the cost of floating-point divisions of mode MODE.  */
3881 +
3882 +static int
3883 +mips_fp_div_cost (enum machine_mode mode)
3884 +{
3885 +  return mode == DFmode ? mips_cost->fp_div_df : mips_cost->fp_div_sf;
3886 +}
3887 +
3888 +/* Return the cost of sign-extending OP to mode MODE, not including the
3889 +   cost of OP itself.  */
3890 +
3891 +static int
3892 +mips_sign_extend_cost (enum machine_mode mode, rtx op)
3893 +{
3894 +  if (MEM_P (op))
3895 +    /* Extended loads are as cheap as unextended ones.  */
3896 +    return 0;
3897 +
3898 +  if (TARGET_64BIT && mode == DImode && GET_MODE (op) == SImode)
3899 +    /* A sign extension from SImode to DImode in 64-bit mode is free.  */
3900 +    return 0;
3901 +
3902 +  /* We need to use a shift left and a shift right.  */
3903 +  return COSTS_N_INSNS (2);
3904 +}
3905 +
3906 +/* Return the cost of zero-extending OP to mode MODE, not including the
3907 +   cost of OP itself.  */
3908 +
3909 +static int
3910 +mips_zero_extend_cost (enum machine_mode mode, rtx op)
3911 +{
3912 +  if (MEM_P (op))
3913 +    /* Extended loads are as cheap as unextended ones.  */
3914 +    return 0;
3915 +
3916 +  if ((TARGET_64BIT && mode == DImode && GET_MODE (op) == SImode) ||
3917 +      ((mode == DImode || mode == SImode) && GET_MODE (op) == HImode))
3918 +    /* We need a shift left by 32 bits and a shift right by 32 bits.  */
3919 +    return COSTS_N_INSNS (2);
3920 +
3921 +  /* We can use ANDI.  */
3922 +  return COSTS_N_INSNS (1);
3923 +}
3924 +
3925 +/* Implement TARGET_RTX_COSTS.  */
3926 +
3927 +static bool
3928 +mips_rtx_costs (rtx x, int code, int outer_code, int *total, bool speed)
3929 +{
3930 +  enum machine_mode mode = GET_MODE (x);
3931 +  bool float_mode_p = FLOAT_MODE_P (mode);
3932 +  int cost;
3933 +  rtx addr;
3934 +
3935 +  /* The cost of a COMPARE is hard to define for MIPS.  COMPAREs don't
3936 +     appear in the instruction stream, and the cost of a comparison is
3937 +     really the cost of the branch or scc condition.  At the time of
3938 +     writing, GCC only uses an explicit outer COMPARE code when optabs
3939 +     is testing whether a constant is expensive enough to force into a
3940 +     register.  We want optabs to pass such constants through the MIPS
3941 +     expanders instead, so make all constants very cheap here.  */
3942 +  if (outer_code == COMPARE)
3943 +    {
3944 +      gcc_assert (CONSTANT_P (x));
3945 +      *total = 0;
3946 +      return true;
3947 +    }
3948 +
3949 +  switch (code)
3950 +    {
3951 +    case CONST_INT:
3952 +      /* Treat *clear_upper32-style ANDs as having zero cost in the
3953 +        second operand.  The cost is entirely in the first operand.
3954 +
3955 +        ??? This is needed because we would otherwise try to CSE
3956 +        the constant operand.  Although that's the right thing for
3957 +        instructions that continue to be a register operation throughout
3958 +        compilation, it is disastrous for instructions that could
3959 +        later be converted into a memory operation.  */
3960 +      if (TARGET_64BIT
3961 +         && outer_code == AND
3962 +         && UINTVAL (x) == 0xffffffff)
3963 +       {
3964 +         *total = 0;
3965 +         return true;
3966 +       }
3967 +
3968 +      /* When not optimizing for size, we care more about the cost
3969 +         of hot code, and hot code is often in a loop.  If a constant
3970 +         operand needs to be forced into a register, we will often be
3971 +         able to hoist the constant load out of the loop, so the load
3972 +         should not contribute to the cost.  */
3973 +      if (speed || mips_immediate_operand_p (outer_code, INTVAL (x)))
3974 +        {
3975 +          *total = 0;
3976 +          return true;
3977 +        }
3978 +      /* Fall through.  */
3979 +
3980 +    case CONST:
3981 +    case SYMBOL_REF:
3982 +    case LABEL_REF:
3983 +    case CONST_DOUBLE:
3984 +      cost = mips_const_insns (x);
3985 +      if (cost > 0)
3986 +       {
3987 +         /* If the constant is likely to be stored in a GPR, SETs of
3988 +            single-insn constants are as cheap as register sets; we
3989 +            never want to CSE them.
3990 +
3991 +            Don't reduce the cost of storing a floating-point zero in
3992 +            FPRs.  If we have a zero in an FPR for other reasons, we
3993 +            can get better cfg-cleanup and delayed-branch results by
3994 +            using it consistently, rather than using $0 sometimes and
3995 +            an FPR at other times.  Also, moves between floating-point
3996 +            registers are sometimes cheaper than (D)MTC1 $0.  */
3997 +         if (cost == 1
3998 +             && outer_code == SET
3999 +             && !(float_mode_p && TARGET_HARD_FLOAT))
4000 +           cost = 0;
4001 +         /* When non-MIPS16 code loads a constant N>1 times, we rarely
4002 +            want to CSE the constant itself.  It is usually better to
4003 +            have N copies of the last operation in the sequence and one
4004 +            shared copy of the other operations.  (Note that this is
4005 +            not true for MIPS16 code, where the final operation in the
4006 +            sequence is often an extended instruction.)
4007 +
4008 +            Also, if we have a CONST_INT, we don't know whether it is
4009 +            for a word or doubleword operation, so we cannot rely on
4010 +            the result of riscv_build_integer.  */
4011 +         else if (outer_code == SET || mode == VOIDmode)
4012 +           cost = 1;
4013 +         *total = COSTS_N_INSNS (cost);