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