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