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