Add the 'akaros' threading model to gcc (XCC)
[akaros.git] / tools / compilers / gcc-glibc / gcc-4.9.2-riscv.patch
1 diff -ruN gcc-4.9.2/config.sub gcc-4.9.2-riscv/config.sub
2 --- gcc-4.9.2/config.sub        2013-10-01 09:50:56.000000000 -0700
3 +++ gcc-4.9.2-riscv/config.sub  2014-12-02 18:04:50.107949563 -0800
4 @@ -334,6 +334,9 @@
5         ms1)
6                 basic_machine=mt-unknown
7                 ;;
8 +       riscv)
9 +               basic_machine=riscv-ucb
10 +               ;;
11  
12         strongarm | thumb | xscale)
13                 basic_machine=arm-unknown
14 diff -ruN gcc-4.9.2/gcc/config/riscv/constraints.md gcc-4.9.2-riscv/gcc/config/riscv/constraints.md
15 --- gcc-4.9.2/gcc/config/riscv/constraints.md   1969-12-31 16:00:00.000000000 -0800
16 +++ gcc-4.9.2-riscv/gcc/config/riscv/constraints.md     2014-12-02 18:04:50.107949563 -0800
17 @@ -0,0 +1,121 @@
18 +;; Constraint definitions for MIPS.
19 +;; Copyright (C) 2006, 2007, 2008, 2010 Free Software Foundation, Inc.
20 +;;
21 +;; This file is part of GCC.
22 +;;
23 +;; GCC is free software; you can redistribute it and/or modify
24 +;; it under the terms of the GNU General Public License as published by
25 +;; the Free Software Foundation; either version 3, or (at your option)
26 +;; any later version.
27 +;;
28 +;; GCC is distributed in the hope that it will be useful,
29 +;; but WITHOUT ANY WARRANTY; without even the implied warranty of
30 +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
31 +;; GNU General Public License for more details.
32 +;;
33 +;; You should have received a copy of the GNU General Public License
34 +;; along with GCC; see the file COPYING3.  If not see
35 +;; <http://www.gnu.org/licenses/>.
36 +
37 +;; Vector register constraints
38 +
39 +(define_register_constraint "A" "VEC_GR_REGS"
40 +  "A vector integer register.")
41 +
42 +(define_register_constraint "B" "VEC_FP_REGS"
43 +  "A vector floating-point register.")
44 +
45 +;; Register constraints
46 +
47 +(define_register_constraint "d" "GR_REGS"
48 +  "An address register.  This is equivalent to @code{r} unless
49 +   generating MIPS16 code.")
50 +
51 +(define_register_constraint "f" "TARGET_HARD_FLOAT ? FP_REGS : NO_REGS"
52 +  "A floating-point register (if available).")
53 +
54 +(define_register_constraint "h" "NO_REGS"
55 +  "Formerly the @code{hi} register.  This constraint is no longer supported.")
56 +
57 +(define_register_constraint "b" "ALL_REGS"
58 +  "@internal")
59 +
60 +(define_register_constraint "j" "V1_REG"
61 +  "@internal")
62 +
63 +(define_register_constraint "z" "GR_REGS"
64 +  "A floating-point condition code register.")
65 +
66 +;; This is a normal rather than a register constraint because we can
67 +;; never use the stack pointer as a reload register.
68 +(define_constraint "ks"
69 +  "@internal"
70 +  (and (match_code "reg")
71 +       (match_test "REGNO (op) == STACK_POINTER_REGNUM")))
72 +
73 +;; Integer constraints
74 +
75 +(define_constraint "Z"
76 +  "@internal"
77 +  (and (match_code "const_int")
78 +       (match_test "1")))
79 +
80 +(define_constraint "I"
81 +  "An I-type 12-bit signed immediate."
82 +  (and (match_code "const_int")
83 +       (match_test "SMALL_OPERAND (ival)")))
84 +
85 +(define_constraint "J"
86 +  "Integer zero."
87 +  (and (match_code "const_int")
88 +       (match_test "ival == 0")))
89 +
90 +;; Floating-point constraints
91 +
92 +(define_constraint "G"
93 +  "Floating-point zero."
94 +  (and (match_code "const_double")
95 +       (match_test "op == CONST0_RTX (mode)")))
96 +
97 +;; General constraints
98 +
99 +(define_constraint "Q"
100 +  "@internal"
101 +  (match_operand 0 "const_arith_operand"))
102 +
103 +(define_memory_constraint "YR"
104 +  "An address that is held in a general-purpose register."
105 +  (and (match_code "mem")
106 +       (match_test "GET_CODE(XEXP(op,0)) == REG")))
107 +
108 +(define_memory_constraint "R"
109 +  "An address that can be used in a non-macro load or store."
110 +  (and (match_code "mem")
111 +       (match_test "mips_address_insns (XEXP (op, 0), mode, false) == 1")))
112 +
113 +(define_constraint "S"
114 +  "@internal
115 +   A constant call address."
116 +  (and (match_operand 0 "call_insn_operand")
117 +       (match_test "CONSTANT_P (op)")))
118 +
119 +(define_constraint "T"
120 +  "@internal
121 +   A constant @code{move_operand}."
122 +  (and (match_operand 0 "move_operand")
123 +       (match_test "CONSTANT_P (op)")))
124 +
125 +(define_memory_constraint "W"
126 +  "@internal
127 +   A memory address based on a member of @code{BASE_REG_CLASS}.  This is
128 +   true for all references (although it can sometimes be implicit if
129 +   @samp{!TARGET_EXPLICIT_RELOCS}).  For MIPS16, it excludes stack and
130 +   constant-pool references."
131 +  (and (match_code "mem")
132 +       (match_operand 0 "memory_operand")))
133 +
134 +(define_constraint "YG"
135 +  "@internal
136 +   A vector zero."
137 +  (and (match_code "const_vector")
138 +       (match_test "op == CONST0_RTX (mode)")))
139 diff -ruN gcc-4.9.2/gcc/config/riscv/crti.asm gcc-4.9.2-riscv/gcc/config/riscv/crti.asm
140 --- gcc-4.9.2/gcc/config/riscv/crti.asm 1969-12-31 16:00:00.000000000 -0800
141 +++ gcc-4.9.2-riscv/gcc/config/riscv/crti.asm   2014-12-02 18:04:50.107949563 -0800
142 @@ -0,0 +1,42 @@
143 +/* Copyright (C) 2001, 2002 Free Software Foundation, Inc.
144 +
145 +This file is part of GCC.
146 +
147 +GCC is free software; you can redistribute it and/or modify it under
148 +the terms of the GNU General Public License as published by the Free
149 +Software Foundation; either version 3, or (at your option) any later
150 +version.
151 +
152 +GCC is distributed in the hope that it will be useful, but WITHOUT ANY
153 +WARRANTY; without even the implied warranty of MERCHANTABILITY or
154 +FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
155 +for more details.
156 +
157 +Under Section 7 of GPL version 3, you are granted additional
158 +permissions described in the GCC Runtime Library Exception, version
159 +3.1, as published by the Free Software Foundation.
160 +
161 +You should have received a copy of the GNU General Public License and
162 +a copy of the GCC Runtime Library Exception along with this program;
163 +see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
164 +<http://www.gnu.org/licenses/>.  */
165 +
166 +#ifdef __riscv64
167 +# define SR sd
168 +#else
169 +# define SR sw
170 +#endif
171 +
172 +       .section .init,"ax",@progbits
173 +       .globl  _init
174 +       .type   _init,@function
175 +_init:
176 +       add     sp, sp, -8
177 +       SR      ra, 0(sp)
178 +
179 +       .section .fini,"ax",@progbits
180 +       .globl  _fini
181 +       .type   _fini,@function
182 +_fini:
183 +       add     sp, sp, -8
184 +       SR      ra, 0(sp)
185 diff -ruN gcc-4.9.2/gcc/config/riscv/crtn.asm gcc-4.9.2-riscv/gcc/config/riscv/crtn.asm
186 --- gcc-4.9.2/gcc/config/riscv/crtn.asm 1969-12-31 16:00:00.000000000 -0800
187 +++ gcc-4.9.2-riscv/gcc/config/riscv/crtn.asm   2014-12-02 18:04:50.107949563 -0800
188 @@ -0,0 +1,38 @@
189 +/* Copyright (C) 2001, 2002 Free Software Foundation, Inc.
190 +
191 +This file is part of GCC.
192 +
193 +GCC is free software; you can redistribute it and/or modify it under
194 +the terms of the GNU General Public License as published by the Free
195 +Software Foundation; either version 3, or (at your option) any later
196 +version.
197 +
198 +GCC is distributed in the hope that it will be useful, but WITHOUT ANY
199 +WARraNTY; without even the implied warranty of MERCHANTABILITY or
200 +FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
201 +for more details.
202 +
203 +Under Section 7 of GPL version 3, you are granted additional
204 +permissions described in the GCC Runtime Library Exception, version
205 +3.1, as published by the Free Software Foundation.
206 +
207 +You should have received a copy of the GNU General Public License and
208 +a copy of the GCC Runtime Library Exception along with this program;
209 +see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
210 +<http://www.gnu.org/licenses/>.  */
211 +
212 +#ifdef __riscv64
213 +# define LR ld
214 +#else
215 +# define LR lw
216 +#endif
217 +
218 +       .section .init,"ax",@progbits
219 +       LR      ra, 0(sp)
220 +       addi    sp, sp, 8
221 +       ret
222 +
223 +       .section .fini,"ax",@progbits
224 +       LR      ra, 0(sp)
225 +       addi    sp, sp, 8
226 +       ret
227 diff -ruN gcc-4.9.2/gcc/config/riscv/elf.h gcc-4.9.2-riscv/gcc/config/riscv/elf.h
228 --- gcc-4.9.2/gcc/config/riscv/elf.h    1969-12-31 16:00:00.000000000 -0800
229 +++ gcc-4.9.2-riscv/gcc/config/riscv/elf.h      2014-12-02 18:04:50.107949563 -0800
230 @@ -0,0 +1,51 @@
231 +/* Target macros for mips*-elf targets.
232 +   Copyright (C) 1994, 1997, 1999, 2000, 2002, 2003, 2004, 2007, 2010
233 +   Free Software Foundation, Inc.
234 +
235 +This file is part of GCC.
236 +
237 +GCC is free software; you can redistribute it and/or modify
238 +it under the terms of the GNU General Public License as published by
239 +the Free Software Foundation; either version 3, or (at your option)
240 +any later version.
241 +
242 +GCC is distributed in the hope that it will be useful,
243 +but WITHOUT ANY WARRANTY; without even the implied warranty of
244 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
245 +GNU General Public License for more details.
246 +
247 +You should have received a copy of the GNU General Public License
248 +along with GCC; see the file COPYING3.  If not see
249 +<http://www.gnu.org/licenses/>.  */
250 +
251 +/* MIPS assemblers don't have the usual .set foo,bar construct;
252 +   .set is used for assembler options instead.  */
253 +#undef SET_ASM_OP
254 +#define ASM_OUTPUT_DEF(FILE, LABEL1, LABEL2)                   \
255 +  do                                                           \
256 +    {                                                          \
257 +      fputc ('\t', FILE);                                      \
258 +      assemble_name (FILE, LABEL1);                            \
259 +      fputs (" = ", FILE);                                     \
260 +      assemble_name (FILE, LABEL2);                            \
261 +      fputc ('\n', FILE);                                      \
262 +    }                                                          \
263 +  while (0)
264 +
265 +#undef ASM_DECLARE_OBJECT_NAME
266 +#define ASM_DECLARE_OBJECT_NAME mips_declare_object_name
267 +
268 +#undef ASM_FINISH_DECLARE_OBJECT
269 +#define ASM_FINISH_DECLARE_OBJECT mips_finish_declare_object
270 +
271 +/* Leave the linker script to choose the appropriate libraries.  */
272 +#undef  LIB_SPEC
273 +#define LIB_SPEC ""
274 +
275 +#undef  STARTFILE_SPEC
276 +#define STARTFILE_SPEC "crti%O%s crtbegin%O%s"
277 +
278 +#undef  ENDFILE_SPEC
279 +#define ENDFILE_SPEC "crtend%O%s crtn%O%s"
280 +
281 +#define NO_IMPLICIT_EXTERN_C 1
282 diff -ruN gcc-4.9.2/gcc/config/riscv/generic.md gcc-4.9.2-riscv/gcc/config/riscv/generic.md
283 --- gcc-4.9.2/gcc/config/riscv/generic.md       1969-12-31 16:00:00.000000000 -0800
284 +++ gcc-4.9.2-riscv/gcc/config/riscv/generic.md 2014-12-02 18:04:50.107949563 -0800
285 @@ -0,0 +1,105 @@
286 +;; Generic DFA-based pipeline description for MIPS targets
287 +;;   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
288 +;;
289 +;; This file is part of GCC.
290 +
291 +;; GCC is free software; you can redistribute it and/or modify it
292 +;; under the terms of the GNU General Public License as published
293 +;; by the Free Software Foundation; either version 3, or (at your
294 +;; option) any later version.
295 +
296 +;; GCC is distributed in the hope that it will be useful, but WITHOUT
297 +;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
298 +;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
299 +;; License for more details.
300 +
301 +;; You should have received a copy of the GNU General Public License
302 +;; along with GCC; see the file COPYING3.  If not see
303 +;; <http://www.gnu.org/licenses/>.
304 +
305 +
306 +;; This file is derived from the old define_function_unit description.
307 +;; Each reservation can be overridden on a processor-by-processor basis.
308 +
309 +(define_insn_reservation "generic_alu" 1
310 +  (eq_attr "type" "unknown,prefetch,prefetchx,condmove,const,arith,
311 +                  shift,slt,clz,trap,multi,nop,logical,signext,move")
312 +  "alu")
313 +
314 +(define_insn_reservation "generic_load" 3
315 +  (eq_attr "type" "load,fpload,fpidxload")
316 +  "alu")
317 +
318 +(define_insn_reservation "generic_store" 1
319 +  (eq_attr "type" "store,fpstore,fpidxstore")
320 +  "alu")
321 +
322 +(define_insn_reservation "generic_xfer" 2
323 +  (eq_attr "type" "mfc,mtc")
324 +  "alu")
325 +
326 +(define_insn_reservation "generic_branch" 1
327 +  (eq_attr "type" "branch,jump,call")
328 +  "alu")
329 +
330 +(define_insn_reservation "generic_hilo" 1
331 +  (eq_attr "type" "mfhilo,mthilo")
332 +  "imuldiv*3")
333 +
334 +(define_insn_reservation "generic_imul" 17
335 +  (eq_attr "type" "imul,imul3,imadd")
336 +  "imuldiv*17")
337 +
338 +(define_insn_reservation "generic_idiv" 38
339 +  (eq_attr "type" "idiv")
340 +  "imuldiv*38")
341 +
342 +(define_insn_reservation "generic_fcvt" 1
343 +  (eq_attr "type" "fcvt")
344 +  "alu")
345 +
346 +(define_insn_reservation "generic_fmove" 2
347 +  (eq_attr "type" "fabs,fneg,fmove")
348 +  "alu")
349 +
350 +(define_insn_reservation "generic_fcmp" 3
351 +  (eq_attr "type" "fcmp")
352 +  "alu")
353 +
354 +(define_insn_reservation "generic_fadd" 4
355 +  (eq_attr "type" "fadd")
356 +  "alu")
357 +
358 +(define_insn_reservation "generic_fmul_single" 7
359 +  (and (eq_attr "type" "fmul,fmadd")
360 +       (eq_attr "mode" "SF"))
361 +  "alu")
362 +
363 +(define_insn_reservation "generic_fmul_double" 8
364 +  (and (eq_attr "type" "fmul,fmadd")
365 +       (eq_attr "mode" "DF"))
366 +  "alu")
367 +
368 +(define_insn_reservation "generic_fdiv_single" 23
369 +  (and (eq_attr "type" "fdiv,frdiv")
370 +       (eq_attr "mode" "SF"))
371 +  "alu")
372 +
373 +(define_insn_reservation "generic_fdiv_double" 36
374 +  (and (eq_attr "type" "fdiv,frdiv")
375 +       (eq_attr "mode" "DF"))
376 +  "alu")
377 +
378 +(define_insn_reservation "generic_fsqrt_single" 54
379 +  (and (eq_attr "type" "fsqrt,frsqrt")
380 +       (eq_attr "mode" "SF"))
381 +  "alu")
382 +
383 +(define_insn_reservation "generic_fsqrt_double" 112
384 +  (and (eq_attr "type" "fsqrt,frsqrt")
385 +       (eq_attr "mode" "DF"))
386 +  "alu")
387 +
388 +(define_insn_reservation "generic_frecip_fsqrt_step" 5
389 +  (eq_attr "type" "frdiv1,frdiv2,frsqrt1,frsqrt2")
390 +  "alu")
391 diff -ruN gcc-4.9.2/gcc/config/riscv/linux64.h gcc-4.9.2-riscv/gcc/config/riscv/linux64.h
392 --- gcc-4.9.2/gcc/config/riscv/linux64.h        1969-12-31 16:00:00.000000000 -0800
393 +++ gcc-4.9.2-riscv/gcc/config/riscv/linux64.h  2014-12-02 18:04:50.107949563 -0800
394 @@ -0,0 +1,58 @@
395 +/* Definitions for MIPS running Linux-based GNU systems with ELF format
396 +   using n32/64 abi.
397 +   Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011
398 +   Free Software Foundation, Inc.
399 +
400 +This file is part of GCC.
401 +
402 +GCC is free software; you can redistribute it and/or modify
403 +it under the terms of the GNU General Public License as published by
404 +the Free Software Foundation; either version 3, or (at your option)
405 +any later version.
406 +
407 +GCC is distributed in the hope that it will be useful,
408 +but WITHOUT ANY WARRANTY; without even the implied warranty of
409 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
410 +GNU General Public License for more details.
411 +
412 +You should have received a copy of the GNU General Public License
413 +along with GCC; see the file COPYING3.  If not see
414 +<http://www.gnu.org/licenses/>.  */
415 +
416 +/* Force the default endianness and ABI flags onto the command line
417 +   in order to make the other specs easier to write.  */
418 +#undef DRIVER_SELF_SPECS
419 +#define DRIVER_SELF_SPECS \
420 +  LINUX_DRIVER_SELF_SPECS \
421 +  " %{!EB:%{!EL:%(endian_spec)}}" \
422 +  " %{" OPT_ARCH32 ": -m32} %{" OPT_ARCH64 ": -m64}" \
423 +
424 +#undef LIB_SPEC
425 +#define LIB_SPEC "\
426 +%{pthread:-lpthread} \
427 +%{shared:-lc} \
428 +%{!shared: \
429 +  %{profile:-lc_p} %{!profile:-lc}}"
430 +
431 +#define GLIBC_DYNAMIC_LINKER32 "/lib32/ld.so.1"
432 +#define GLIBC_DYNAMIC_LINKER64 "/lib/ld.so.1"
433 +
434 +#undef LINK_SPEC
435 +#define LINK_SPEC "\
436 +%{G*} %{EB} %{EL} %{mips1} %{mips2} %{mips3} %{mips4} \
437 +%{shared} \
438 + %(endian_spec) \
439 +  %{!shared: \
440 +    %{!static: \
441 +      %{rdynamic:-export-dynamic} \
442 +      %{" OPT_ARCH64 ": -dynamic-linker " LINUX_DYNAMIC_LINKER64 "} \
443 +      %{" OPT_ARCH32 ": -dynamic-linker " LINUX_DYNAMIC_LINKER32 "}} \
444 +    %{static:-static}} \
445 +%{" OPT_ARCH64 ":-melf64%{EB:b}%{EL:l}riscv} \
446 +%{" OPT_ARCH32 ":-melf32%{EB:b}%{EL:l}riscv}"
447 +
448 +/* GNU/Linux doesn't use the same floating-point format that IRIX uses
449 +   for long double.  There's no need to override this here, since
450 +   ieee_quad_format is the default, but let's put this here to make
451 +   sure nobody thinks we just forgot to set it to something else.  */
452 +#define MIPS_TFMODE_FORMAT mips_quad_format
453 diff -ruN gcc-4.9.2/gcc/config/riscv/linux.h gcc-4.9.2-riscv/gcc/config/riscv/linux.h
454 --- gcc-4.9.2/gcc/config/riscv/linux.h  1969-12-31 16:00:00.000000000 -0800
455 +++ gcc-4.9.2-riscv/gcc/config/riscv/linux.h    2014-12-02 18:04:50.107949563 -0800
456 @@ -0,0 +1,115 @@
457 +/* Definitions for MIPS running Linux-based GNU systems with ELF format.
458 +   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
459 +   2007, 2008, 2010, 2011 Free Software Foundation, Inc.
460 +
461 +This file is part of GCC.
462 +
463 +GCC is free software; you can redistribute it and/or modify
464 +it under the terms of the GNU General Public License as published by
465 +the Free Software Foundation; either version 3, or (at your option)
466 +any later version.
467 +
468 +GCC is distributed in the hope that it will be useful,
469 +but WITHOUT ANY WARRANTY; without even the implied warranty of
470 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
471 +GNU General Public License for more details.
472 +
473 +You should have received a copy of the GNU General Public License
474 +along with GCC; see the file COPYING3.  If not see
475 +<http://www.gnu.org/licenses/>.  */
476 +
477 +#undef WCHAR_TYPE
478 +#define WCHAR_TYPE "int"
479 +
480 +#undef WCHAR_TYPE_SIZE
481 +#define WCHAR_TYPE_SIZE 32
482 +
483 +#undef ASM_DECLARE_OBJECT_NAME
484 +#define ASM_DECLARE_OBJECT_NAME mips_declare_object_name
485 +
486 +#undef TARGET_VERSION
487 +#if TARGET_ENDIAN_DEFAULT == 0
488 +#define TARGET_VERSION fprintf (stderr, " (RISC-V LE Linux/ELF)");
489 +#else
490 +#define TARGET_VERSION fprintf (stderr, " (RISC-V BE Linux/ELF)");
491 +#endif
492 +
493 +/* If we don't set MASK_ABICALLS, we can't default to PIC.  */
494 +#undef TARGET_DEFAULT
495 +#define TARGET_DEFAULT MASK_ABICALLS
496 +
497 +#define TARGET_OS_CPP_BUILTINS()                               \
498 +  do {                                                         \
499 +    LINUX_TARGET_OS_CPP_BUILTINS();                            \
500 +    /* The GNU C++ standard library requires this.  */         \
501 +    if (c_dialect_cxx ())                                      \
502 +      builtin_define ("_GNU_SOURCE");                          \
503 +  } while (0)
504 +
505 +#undef SUBTARGET_CPP_SPEC
506 +#define SUBTARGET_CPP_SPEC "%{posix:-D_POSIX_SOURCE} %{pthread:-D_REENTRANT}"
507 +
508 +/* A standard GNU/Linux mapping.  On most targets, it is included in
509 +   CC1_SPEC itself by config/linux.h, but mips.h overrides CC1_SPEC
510 +   and provides this hook instead.  */
511 +#undef SUBTARGET_CC1_SPEC
512 +#define SUBTARGET_CC1_SPEC "%{profile:-p}"
513 +
514 +#define GLIBC_DYNAMIC_LINKER "/lib/ld.so.1"
515 +
516 +/* Borrowed from sparc/linux.h */
517 +#undef LINK_SPEC
518 +#define LINK_SPEC \
519 + "%(endian_spec) \
520 +  %{shared:-shared} \
521 +  %{!shared: \
522 +    %{!static: \
523 +      %{rdynamic:-export-dynamic} \
524 +      -dynamic-linker " LINUX_DYNAMIC_LINKER "} \
525 +      %{static:-static}}"
526 +
527 +/* The MIPS assembler has different syntax for .set. We set it to
528 +   .dummy to trap any errors.  */
529 +#undef SET_ASM_OP
530 +#define SET_ASM_OP "\t.dummy\t"
531 +
532 +#undef ASM_OUTPUT_DEF
533 +#define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)                             \
534 + do {                                                                  \
535 +       fputc ( '\t', FILE);                                            \
536 +       assemble_name (FILE, LABEL1);                                   \
537 +       fputs ( " = ", FILE);                                           \
538 +       assemble_name (FILE, LABEL2);                                   \
539 +       fputc ( '\n', FILE);                                            \
540 + } while (0)
541 +
542 +/* The glibc _mcount stub will save $v0 for us.  Don't mess with saving
543 +   it, since ASM_OUTPUT_REG_PUSH/ASM_OUTPUT_REG_POP do not work in the
544 +   presence of $gp-relative calls.  */
545 +#undef ASM_OUTPUT_REG_PUSH
546 +#undef ASM_OUTPUT_REG_POP
547 +
548 +#undef LIB_SPEC
549 +#define LIB_SPEC "\
550 +%{pthread:-lpthread} \
551 +%{shared:-lc} \
552 +%{!shared: \
553 +  %{profile:-lc_p} %{!profile:-lc}}"
554 +
555 +#define MD_UNWIND_SUPPORT "config/riscv/linux-unwind.h"
556 +
557 +/* -march=native handling only makes sense with compiler running on
558 +   a RISC-V machine.  */
559 +#define MARCH_MTUNE_NATIVE_SPECS ""
560 +
561 +#define LINUX_DRIVER_SELF_SPECS \
562 +  MARCH_MTUNE_NATIVE_SPECS
563 +
564 +#undef DRIVER_SELF_SPECS
565 +#define DRIVER_SELF_SPECS \
566 +  LINUX_DRIVER_SELF_SPECS
567 +
568 +/* Similar to standard Linux, but adding -ffast-math support.  */
569 +#undef  ENDFILE_SPEC
570 +#define ENDFILE_SPEC \
571 +   "%{shared|pie:crtendS.o%s;:crtend.o%s} crtn.o%s"
572 diff -ruN gcc-4.9.2/gcc/config/riscv/linux-unwind.h gcc-4.9.2-riscv/gcc/config/riscv/linux-unwind.h
573 --- gcc-4.9.2/gcc/config/riscv/linux-unwind.h   1969-12-31 16:00:00.000000000 -0800
574 +++ gcc-4.9.2-riscv/gcc/config/riscv/linux-unwind.h     2014-12-02 18:04:50.107949563 -0800
575 @@ -0,0 +1,120 @@
576 +/* DWARF2 EH unwinding support for MIPS Linux.
577 +   Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
578 +
579 +This file is part of GCC.
580 +
581 +GCC is free software; you can redistribute it and/or modify
582 +it under the terms of the GNU General Public License as published by
583 +the Free Software Foundation; either version 3, or (at your option)
584 +any later version.
585 +
586 +GCC is distributed in the hope that it will be useful,
587 +but WITHOUT ANY WARRANTY; without even the implied warranty of
588 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
589 +GNU General Public License for more details.
590 +
591 +Under Section 7 of GPL version 3, you are granted additional
592 +permissions described in the GCC Runtime Library Exception, version
593 +3.1, as published by the Free Software Foundation.
594 +
595 +You should have received a copy of the GNU General Public License and
596 +a copy of the GCC Runtime Library Exception along with this program;
597 +see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
598 +<http://www.gnu.org/licenses/>.  */
599 +
600 +#ifndef inhibit_libc
601 +/* Do code reading to identify a signal frame, and set the frame
602 +   state data appropriately.  See unwind-dw2.c for the structs.  */
603 +
604 +#include <signal.h>
605 +#include <asm/unistd.h>
606 +
607 +/* The third parameter to the signal handler points to something with
608 + * this structure defined in asm/ucontext.h, but the name clashes with
609 + * struct ucontext from sys/ucontext.h so this private copy is used.  */
610 +typedef struct _sig_ucontext {
611 +    unsigned long         uc_flags;
612 +    struct _sig_ucontext  *uc_link;
613 +    stack_t               uc_stack;
614 +    struct sigcontext uc_mcontext;
615 +    sigset_t      uc_sigmask;
616 +} _sig_ucontext_t;
617 +
618 +#define MD_FALLBACK_FRAME_STATE_FOR mips_fallback_frame_state
619 +
620 +static _Unwind_Reason_Code
621 +mips_fallback_frame_state (struct _Unwind_Context *context,
622 +                          _Unwind_FrameState *fs)
623 +{
624 +  u_int32_t *pc = (u_int32_t *) context->ra;
625 +  struct sigcontext *sc;
626 +  _Unwind_Ptr new_cfa, reg_offset;
627 +  int i;
628 +
629 +  /* 24021061 li v0, 0x1061 (rt_sigreturn)*/
630 +  /* 0000000c syscall    */
631 +  /*    or */
632 +  /* 24021017 li v0, 0x1017 (sigreturn) */
633 +  /* 0000000c syscall  */
634 +  if (pc[1] != 0x0000000c)
635 +    return _URC_END_OF_STACK;
636 +#if _MIPS_SIM == _ABIO32
637 +  if (pc[0] == (0x24020000 | __NR_sigreturn))
638 +    {
639 +      struct sigframe {
640 +       u_int32_t ass[4];  /* Argument save space for o32.  */
641 +       u_int32_t trampoline[2];
642 +       struct sigcontext sigctx;
643 +      } *rt_ = context->cfa;
644 +      sc = &rt_->sigctx;
645 +    }
646 +  else
647 +#endif
648 +  if (pc[0] == (0x24020000 | __NR_rt_sigreturn))
649 +    {
650 +      struct rt_sigframe {
651 +       u_int32_t ass[4];  /* Argument save space for o32.  */
652 +       u_int32_t trampoline[2];
653 +       struct siginfo info;
654 +       _sig_ucontext_t uc;
655 +      } *rt_ = context->cfa;
656 +      sc = &rt_->uc.uc_mcontext;
657 +    }
658 +  else
659 +    return _URC_END_OF_STACK;
660 +
661 +  new_cfa = (_Unwind_Ptr) sc;
662 +  fs->regs.cfa_how = CFA_REG_OFFSET;
663 +  fs->regs.cfa_reg = STACK_POINTER_REGNUM;
664 +  fs->regs.cfa_offset = new_cfa - (_Unwind_Ptr) context->cfa;
665 +
666 +  /* On o32 Linux, the register save slots in the sigcontext are
667 +     eight bytes.  We need the lower half of each register slot,
668 +     so slide our view of the structure back four bytes.  */
669 +#if _MIPS_SIM == _ABIO32 && defined __MIPSEB__
670 +  reg_offset = 4;
671 +#else
672 +  reg_offset = 0;
673 +#endif
674 +
675 +  for (i = 0; i < 32; i++) {
676 +    fs->regs.reg[i].how = REG_SAVED_OFFSET;
677 +    fs->regs.reg[i].loc.offset
678 +      = (_Unwind_Ptr)&(sc->sc_regs[i]) + reg_offset - new_cfa;
679 +  }
680 +  /* "PC & -2" points to the faulting instruction, but the unwind code
681 +     searches for "(ADDR & -2) - 1".  (See MASK_RETURN_ADDR for the source
682 +     of the -2 mask.)  Adding 2 here ensures that "(ADDR & -2) - 1" is the
683 +     address of the second byte of the faulting instruction.
684 +
685 +     Note that setting fs->signal_frame would not work.  As the comment
686 +     above MASK_RETURN_ADDR explains, MIPS unwinders must earch for an
687 +     odd-valued address.  */
688 +  fs->regs.reg[DWARF_ALT_FRAME_RETURN_COLUMN].how = REG_SAVED_VAL_OFFSET;
689 +  fs->regs.reg[DWARF_ALT_FRAME_RETURN_COLUMN].loc.offset
690 +    = (_Unwind_Ptr)(sc->sc_pc) + 2 - new_cfa;
691 +  fs->retaddr_column = DWARF_ALT_FRAME_RETURN_COLUMN;
692 +
693 +  return _URC_NO_REASON;
694 +}
695 +#endif
696 diff -ruN gcc-4.9.2/gcc/config/riscv/opcode-riscv.h gcc-4.9.2-riscv/gcc/config/riscv/opcode-riscv.h
697 --- gcc-4.9.2/gcc/config/riscv/opcode-riscv.h   1969-12-31 16:00:00.000000000 -0800
698 +++ gcc-4.9.2-riscv/gcc/config/riscv/opcode-riscv.h     2014-12-02 18:04:50.107949563 -0800
699 @@ -0,0 +1,253 @@
700 +/* riscv.h.  RISC-V opcode list for GDB, the GNU debugger.
701 +   Copyright 2011
702 +   Free Software Foundation, Inc.
703 +   Contributed by Andrew Waterman 
704 +
705 +This file is part of GDB, GAS, and the GNU binutils.
706 +
707 +GDB, GAS, and the GNU binutils are free software; you can redistribute
708 +them and/or modify them under the terms of the GNU General Public
709 +License as published by the Free Software Foundation; either version
710 +1, or (at your option) any later version.
711 +
712 +GDB, GAS, and the GNU binutils are distributed in the hope that they
713 +will be useful, but WITHOUT ANY WARRANTY; without even the implied
714 +warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
715 +the GNU General Public License for more details.
716 +
717 +You should have received a copy of the GNU General Public License
718 +along with this file; see the file COPYING.  If not, write to the Free
719 +Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
720 +
721 +#ifndef _RISCV_H_
722 +#define _RISCV_H_
723 +
724 +/* RVC fields */
725 +
726 +#define OP_MASK_COP            0x1f
727 +#define OP_SH_COP              0
728 +#define OP_MASK_CRD            0x1f
729 +#define OP_SH_CRD              5
730 +#define OP_MASK_CRS2   0x1f
731 +#define OP_SH_CRS2     5
732 +#define OP_MASK_CRS1   0x1f
733 +#define OP_SH_CRS1     10
734 +#define OP_MASK_CRDS           0x7
735 +#define OP_SH_CRDS             13
736 +#define OP_MASK_CRS2S  0x7
737 +#define OP_SH_CRS2S    13
738 +#define OP_MASK_CRS2BS 0x7
739 +#define OP_SH_CRS2BS   5
740 +#define OP_MASK_CRS1S  0x7
741 +#define OP_SH_CRS1S    10
742 +#define OP_MASK_CIMM6  0x3f
743 +#define OP_SH_CIMM6    10
744 +#define OP_MASK_CIMM5  0x1f
745 +#define OP_SH_CIMM5    5
746 +#define OP_MASK_CIMM10 0x3ff
747 +#define OP_SH_CIMM10   5
748 +
749 +static const char rvc_rs1_regmap[8] = { 20, 21, 2, 3, 4, 5, 6, 7 };
750 +#define rvc_rd_regmap rvc_rs1_regmap
751 +#define rvc_rs2b_regmap rvc_rs1_regmap
752 +static const char rvc_rs2_regmap[8] = { 20, 21, 2, 3, 4, 5, 6, 0 };
753 +
754 +#define RVC_JUMP_BITS 10
755 +#define RVC_JUMP_ALIGN_BITS 1
756 +#define RVC_JUMP_ALIGN (1 << RVC_JUMP_ALIGN_BITS)
757 +#define RVC_JUMP_REACH ((1ULL<<RVC_JUMP_BITS)*RVC_JUMP_ALIGN)
758 +
759 +#define RVC_BRANCH_BITS 5
760 +#define RVC_BRANCH_ALIGN_BITS RVC_JUMP_ALIGN_BITS
761 +#define RVC_BRANCH_ALIGN (1 << RVC_BRANCH_ALIGN_BITS)
762 +#define RVC_BRANCH_REACH ((1ULL<<RVC_BRANCH_BITS)*RVC_BRANCH_ALIGN)
763 +
764 +#define RISCV_JTYPE(insn, target) \
765 +  ((MATCH_ ## insn) | (((target) & ((1<<RISCV_JUMP_BITS)-1)) << OP_SH_TARGET))
766 +#define RISCV_LTYPE(insn, rd, bigimm) \
767 +  ((MATCH_ ## insn) | ((rd) << OP_SH_RD) | (((bigimm) & ((1<<RISCV_BIGIMM_BITS)-1)) << OP_SH_BIGIMMEDIATE))
768 +#define RISCV_ITYPE(insn, rd, rs1, imm) \
769 +  ((MATCH_ ## insn) | ((rd) << OP_SH_RD) | ((rs1) << OP_SH_RS) | (((imm) & (RISCV_IMM_REACH-1)) << OP_SH_IMMEDIATE))
770 +#define RISCV_RTYPE(insn, rd, rs1, rs2) \
771 +  ((MATCH_ ## insn) | ((rd) << OP_SH_RD) | ((rs1) << OP_SH_RS) | ((rs2) << OP_SH_RT))
772 +
773 +#define RISCV_NOP RISCV_ITYPE(ADDI, 0, 0, 0)
774 +
775 +#define RISCV_JUMP_TARGET(address) ((address) >> RISCV_JUMP_ALIGN_BITS)
776 +#define RISCV_CONST_HIGH_PART(VALUE) \
777 +  (((VALUE) + (RISCV_IMM_REACH/2)) & ~(RISCV_IMM_REACH-1))
778 +#define RISCV_CONST_LOW_PART(VALUE) ((VALUE) - RISCV_CONST_HIGH_PART (VALUE))
779 +#define RISCV_LUI_HIGH_PART(VALUE) (RISCV_CONST_HIGH_PART(VALUE) >> RISCV_IMM_BITS)
780 +
781 +/* RV fields */
782 +
783 +#define OP_MASK_OP             0x7f
784 +#define OP_SH_OP               0
785 +#define OP_MASK_RT             0x1f
786 +#define OP_SH_RT               17
787 +#define OP_MASK_FT             0x1f
788 +#define OP_SH_FT               17
789 +#define OP_MASK_RS             0x1f
790 +#define OP_SH_RS               22
791 +#define OP_MASK_FS             0x1f
792 +#define OP_SH_FS               22
793 +#define OP_MASK_FR             0x1f
794 +#define OP_SH_FR               12
795 +#define OP_MASK_RD             0x1f
796 +#define OP_SH_RD               27
797 +#define OP_MASK_FD             0x1f
798 +#define OP_SH_FD               27
799 +#define OP_MASK_SHAMT          0x3f
800 +#define OP_SH_SHAMT            10
801 +#define OP_MASK_SHAMTW         0x1f
802 +#define OP_SH_SHAMTW   10
803 +#define OP_MASK_RM             0x7
804 +#define OP_SH_RM       9
805 +
806 +static const char * const riscv_rm[8] =
807 +  { "rne", "rtz", "rdn", "rup", "rmm", 0, 0, "dyn" };
808 +
809 +#define OP_MASK_VRD            0x1f
810 +#define OP_SH_VRD              27
811 +#define OP_MASK_VRS            0x1f
812 +#define OP_SH_VRS              22
813 +#define OP_MASK_VRT            0x1f
814 +#define OP_SH_VRT              17
815 +#define OP_MASK_VRR            0x1f
816 +#define OP_SH_VRR              12
817 +
818 +#define OP_MASK_VFD            0x1f
819 +#define OP_SH_VFD              27
820 +#define OP_MASK_VFS            0x1f
821 +#define OP_SH_VFS              22
822 +#define OP_MASK_VFT            0x1f
823 +#define OP_SH_VFT              17
824 +#define OP_MASK_VFR            0x1f
825 +#define OP_SH_VFR              12
826 +
827 +#define OP_MASK_IMMNGPR         0x3f
828 +#define OP_SH_IMMNGPR           10
829 +#define OP_MASK_IMMNFPR         0x3f
830 +#define OP_SH_IMMNFPR           16
831 +#define OP_MASK_IMMSEGNELM      0x1f
832 +#define OP_SH_IMMSEGNELM        17
833 +#define OP_MASK_IMMSEGSTNELM    0x1f
834 +#define OP_SH_IMMSEGSTNELM      12
835 +
836 +#define LINK_REG 1
837 +
838 +#define RISCV_JUMP_BITS 25
839 +#define RISCV_JUMP_ALIGN_BITS 1
840 +#define RISCV_JUMP_ALIGN (1 << RISCV_JUMP_ALIGN_BITS)
841 +#define RISCV_JUMP_REACH ((1ULL<<RISCV_JUMP_BITS)*RISCV_JUMP_ALIGN)
842 +
843 +#define OP_MASK_TARGET         ((1<<RISCV_JUMP_BITS)-1)
844 +#define OP_SH_TARGET           7
845 +
846 +#define RISCV_IMM_BITS 12
847 +#define RISCV_IMMLO_BITS 7
848 +#define RISCV_IMMHI_BITS (RISCV_IMM_BITS - RISCV_IMMLO_BITS)
849 +#define RISCV_BIGIMM_BITS (32-RISCV_IMM_BITS)
850 +#define RISCV_IMM_REACH (1LL<<RISCV_IMM_BITS)
851 +#define RISCV_BIGIMM_REACH (1LL<<RISCV_BIGIMM_BITS)
852 +#define RISCV_BRANCH_BITS RISCV_IMM_BITS
853 +#define RISCV_BRANCH_ALIGN_BITS RISCV_JUMP_ALIGN_BITS
854 +#define RISCV_BRANCH_ALIGN (1 << RISCV_BRANCH_ALIGN_BITS)
855 +#define RISCV_BRANCH_REACH (RISCV_IMM_REACH*RISCV_BRANCH_ALIGN)
856 +
857 +#define OP_MASK_BIGIMMEDIATE   ((1<<RISCV_BIGIMM_BITS)-1)
858 +#define OP_SH_BIGIMMEDIATE             7
859 +#define OP_MASK_IMMEDIATE      ((1<<RISCV_IMM_BITS)-1)
860 +#define OP_SH_IMMEDIATE                10
861 +#define OP_MASK_IMMLO ((1<<RISCV_IMMLO_BITS)-1)
862 +#define OP_SH_IMMLO   10
863 +#define OP_MASK_IMMHI ((1<<(RISCV_IMM_BITS-RISCV_IMMLO_BITS))-1)
864 +#define OP_SH_IMMHI   27
865 +
866 +#include "riscv-opc.h"
867 +
868 +/* This structure holds information for a particular instruction.  */
869 +
870 +struct riscv_opcode
871 +{
872 +  /* The name of the instruction.  */
873 +  const char *name;
874 +  /* A string describing the arguments for this instruction.  */
875 +  const char *args;
876 +  /* The basic opcode for the instruction.  When assembling, this
877 +     opcode is modified by the arguments to produce the actual opcode
878 +     that is used.  If pinfo is INSN_MACRO, then this is 0.  */
879 +  unsigned long match;
880 +  /* If pinfo is not INSN_MACRO, then this is a bit mask for the
881 +     relevant portions of the opcode when disassembling.  If the
882 +     actual opcode anded with the match field equals the opcode field,
883 +     then we have found the correct instruction.  If pinfo is
884 +     INSN_MACRO, then this field is the macro identifier.  */
885 +  unsigned long mask;
886 +  /* For a macro, this is INSN_MACRO.  Otherwise, it is a collection
887 +     of bits describing the instruction, notably any relevant hazard
888 +     information.  */
889 +  unsigned long pinfo;
890 +};
891 +
892 +#define INSN_WRITE_GPR_D            0x00000001
893 +#define INSN_WRITE_GPR_RA           0x00000004
894 +#define INSN_WRITE_FPR_D            0x00000008
895 +#define INSN_READ_GPR_S             0x00000040
896 +#define INSN_READ_GPR_T             0x00000080
897 +#define INSN_READ_FPR_S             0x00000100
898 +#define INSN_READ_FPR_T             0x00000200
899 +#define INSN_READ_FPR_R                    0x00000400
900 +/* Instruction is a simple alias (I.E. "move" for daddu/addu/or) */
901 +#define        INSN_ALIAS                  0x00001000
902 +/* Instruction is actually a macro.  It should be ignored by the
903 +   disassembler, and requires special treatment by the assembler.  */
904 +#define INSN_MACRO                  0xffffffff
905 +
906 +/* These are the bits which may be set in the pinfo2 field of an
907 +   instruction. */
908 +
909 +/* MIPS ISA defines, use instead of hardcoding ISA level.  */
910 +
911 +#define       ISA_UNKNOWN     0               /* Gas internal use.  */
912 +#define       ISA_RV32        1
913 +#define       ISA_RV64        2
914 +
915 +#define CPU_UNKNOWN    0
916 +#define CPU_ROCKET32 132
917 +#define CPU_ROCKET64 164
918 +
919 +/* This is a list of macro expanded instructions.
920 +
921 +   _I appended means immediate
922 +   _A appended means address
923 +   _AB appended means address with base register
924 +   _D appended means 64 bit floating point constant
925 +   _S appended means 32 bit floating point constant.  */
926 +
927 +enum
928 +{
929 +  M_LA_AB,
930 +  M_J,
931 +  M_LI,
932 +  M_NUM_MACROS
933 +};
934 +
935 +
936 +/* The order of overloaded instructions matters.  Label arguments and
937 +   register arguments look the same. Instructions that can have either
938 +   for arguments must apear in the correct order in this table for the
939 +   assembler to pick the right one. In other words, entries with
940 +   immediate operands must apear after the same instruction with
941 +   registers.
942 +
943 +   Many instructions are short hand for other instructions (i.e., The
944 +   jal <register> instruction is short for jalr <register>).  */
945 +
946 +extern const struct riscv_opcode riscv_builtin_opcodes[];
947 +extern const int bfd_riscv_num_builtin_opcodes;
948 +extern struct riscv_opcode *riscv_opcodes;
949 +extern int bfd_riscv_num_opcodes;
950 +#define NUMOPCODES bfd_riscv_num_opcodes
951 +
952 +#endif /* _MIPS_H_ */
953 diff -ruN gcc-4.9.2/gcc/config/riscv/predicates.md gcc-4.9.2-riscv/gcc/config/riscv/predicates.md
954 --- gcc-4.9.2/gcc/config/riscv/predicates.md    1969-12-31 16:00:00.000000000 -0800
955 +++ gcc-4.9.2-riscv/gcc/config/riscv/predicates.md      2014-12-02 18:04:50.107949563 -0800
956 @@ -0,0 +1,191 @@
957 +;; Predicate definitions for MIPS.
958 +;; Copyright (C) 2004, 2007, 2008 Free Software Foundation, Inc.
959 +;;
960 +;; This file is part of GCC.
961 +;;
962 +;; GCC is free software; you can redistribute it and/or modify
963 +;; it under the terms of the GNU General Public License as published by
964 +;; the Free Software Foundation; either version 3, or (at your option)
965 +;; any later version.
966 +;;
967 +;; GCC is distributed in the hope that it will be useful,
968 +;; but WITHOUT ANY WARRANTY; without even the implied warranty of
969 +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
970 +;; GNU General Public License for more details.
971 +;;
972 +;; You should have received a copy of the GNU General Public License
973 +;; along with GCC; see the file COPYING3.  If not see
974 +;; <http://www.gnu.org/licenses/>.
975 +
976 +(define_predicate "const_arith_operand"
977 +  (and (match_code "const_int")
978 +       (match_test "SMALL_OPERAND (INTVAL (op))")))
979 +
980 +(define_predicate "arith_operand"
981 +  (ior (match_operand 0 "const_arith_operand")
982 +       (match_operand 0 "register_operand")))
983 +
984 +(define_predicate "sle_operand"
985 +  (and (match_code "const_int")
986 +       (match_test "SMALL_OPERAND (INTVAL (op) + 1)")))
987 +
988 +(define_predicate "sleu_operand"
989 +  (and (match_operand 0 "sle_operand")
990 +       (match_test "INTVAL (op) + 1 != 0")))
991 +
992 +(define_predicate "const_0_operand"
993 +  (and (match_code "const_int,const_double,const_vector")
994 +       (match_test "op == CONST0_RTX (GET_MODE (op))")))
995 +
996 +(define_predicate "reg_or_0_operand"
997 +  (ior (match_operand 0 "const_0_operand")
998 +       (match_operand 0 "register_operand")))
999 +
1000 +(define_predicate "const_1_operand"
1001 +  (and (match_code "const_int,const_double,const_vector")
1002 +       (match_test "op == CONST1_RTX (GET_MODE (op))")))
1003 +
1004 +(define_predicate "reg_or_1_operand"
1005 +  (ior (match_operand 0 "const_1_operand")
1006 +       (match_operand 0 "register_operand")))
1007 +
1008 +;; This is used for indexing into vectors, and hence only accepts const_int.
1009 +(define_predicate "const_0_or_1_operand"
1010 +  (and (match_code "const_int")
1011 +       (ior (match_test "op == CONST0_RTX (GET_MODE (op))")
1012 +           (match_test "op == CONST1_RTX (GET_MODE (op))"))))
1013 +
1014 +(define_special_predicate "pc_or_label_operand"
1015 +  (match_code "pc,label_ref"))
1016 +
1017 +(define_predicate "const_call_insn_operand"
1018 +  (match_code "const,symbol_ref,label_ref")
1019 +{
1020 +  enum mips_symbol_type symbol_type;
1021 +
1022 +  if (!mips_symbolic_constant_p (op, &symbol_type))
1023 +    return false;
1024 +
1025 +  if (symbol_type == SYMBOL_ABSOLUTE)
1026 +    {
1027 +      if (GET_CODE (op) == SYMBOL_REF)
1028 +       {
1029 +         if (flag_pic && !riscv_symbol_binds_local_p (op))
1030 +           return false;
1031 +         if (SYMBOL_REF_LONG_CALL_P (op))
1032 +           return false;
1033 +       }
1034 +      return true;
1035 +    }
1036 +
1037 +  return false;
1038 +})
1039 +
1040 +(define_predicate "call_insn_operand"
1041 +  (ior (match_operand 0 "const_call_insn_operand")
1042 +       (match_operand 0 "register_operand")))
1043 +
1044 +;; A legitimate CONST_INT operand that takes more than one instruction
1045 +;; to load.
1046 +(define_predicate "splittable_const_int_operand"
1047 +  (match_code "const_int")
1048 +{
1049 +  /* Don't handle multi-word moves this way; we don't want to introduce
1050 +     the individual word-mode moves until after reload.  */
1051 +  if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
1052 +    return false;
1053 +
1054 +  /* Otherwise check whether the constant can be loaded in a single
1055 +     instruction.  */
1056 +  return !LUI_INT (op) && !SMALL_INT (op);
1057 +})
1058 +
1059 +(define_predicate "move_operand"
1060 +  (match_operand 0 "general_operand")
1061 +{
1062 +  enum mips_symbol_type symbol_type;
1063 +
1064 +  /* The thinking here is as follows:
1065 +
1066 +     (1) The move expanders should split complex load sequences into
1067 +        individual instructions.  Those individual instructions can
1068 +        then be optimized by all rtl passes.
1069 +
1070 +     (2) The target of pre-reload load sequences should not be used
1071 +        to store temporary results.  If the target register is only
1072 +        assigned one value, reload can rematerialize that value
1073 +        on demand, rather than spill it to the stack.
1074 +
1075 +     (3) If we allowed pre-reload passes like combine and cse to recreate
1076 +        complex load sequences, we would want to be able to split the
1077 +        sequences before reload as well, so that the pre-reload scheduler
1078 +        can see the individual instructions.  This falls foul of (2);
1079 +        the splitter would be forced to reuse the target register for
1080 +        intermediate results.
1081 +
1082 +     (4) We want to define complex load splitters for combine.  These
1083 +        splitters can request a temporary scratch register, which avoids
1084 +        the problem in (2).  They allow things like:
1085 +
1086 +             (set (reg T1) (high SYM))
1087 +             (set (reg T2) (low (reg T1) SYM))
1088 +             (set (reg X) (plus (reg T2) (const_int OFFSET)))
1089 +
1090 +        to be combined into:
1091 +
1092 +             (set (reg T3) (high SYM+OFFSET))
1093 +             (set (reg X) (lo_sum (reg T3) SYM+OFFSET))
1094 +
1095 +        if T2 is only used this once.  */
1096 +  switch (GET_CODE (op))
1097 +    {
1098 +    case CONST_INT:
1099 +      return !splittable_const_int_operand (op, mode);
1100 +
1101 +    case CONST:
1102 +    case SYMBOL_REF:
1103 +    case LABEL_REF:
1104 +      return (mips_symbolic_constant_p (op, &symbol_type)
1105 +             && !mips_split_p[symbol_type]);
1106 +
1107 +    case HIGH:
1108 +      op = XEXP (op, 0);
1109 +      return mips_symbolic_constant_p (op, &symbol_type);
1110 +
1111 +    default:
1112 +      return true;
1113 +    }
1114 +})
1115 +
1116 +(define_predicate "consttable_operand"
1117 +  (match_test "CONSTANT_P (op)"))
1118 +
1119 +(define_predicate "symbolic_operand"
1120 +  (match_code "const,symbol_ref,label_ref")
1121 +{
1122 +  enum mips_symbol_type type;
1123 +  return mips_symbolic_constant_p (op, &type);
1124 +})
1125 +
1126 +(define_predicate "absolute_symbolic_operand"
1127 +  (match_code "const,symbol_ref,label_ref")
1128 +{
1129 +  enum mips_symbol_type type;
1130 +  return (mips_symbolic_constant_p (op, &type)
1131 +         && type == SYMBOL_ABSOLUTE);
1132 +})
1133 +
1134 +(define_predicate "symbol_ref_operand"
1135 +  (match_code "symbol_ref"))
1136 +
1137 +(define_predicate "equality_operator"
1138 +  (match_code "eq,ne"))
1139 +
1140 +(define_predicate "order_operator"
1141 +  (match_code "eq,ne,lt,ltu,le,leu,ge,geu,gt,gtu"))
1142 +
1143 +(define_predicate "fp_order_operator"
1144 +  (match_code "eq,lt,le,gt,ge"))
1145 +
1146 +(define_predicate "fp_unorder_operator"
1147 +  (match_code "ordered,unordered"))
1148 diff -ruN gcc-4.9.2/gcc/config/riscv/riscv.c gcc-4.9.2-riscv/gcc/config/riscv/riscv.c
1149 --- gcc-4.9.2/gcc/config/riscv/riscv.c  1969-12-31 16:00:00.000000000 -0800
1150 +++ gcc-4.9.2-riscv/gcc/config/riscv/riscv.c    2014-12-02 18:04:50.111949590 -0800
1151 @@ -0,0 +1,5958 @@
1152 +/* Subroutines used for MIPS code generation.
1153 +   Copyright (C) 1989, 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998,
1154 +   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
1155 +   2011
1156 +   Free Software Foundation, Inc.
1157 +   Contributed by A. Lichnewsky, lich@inria.inria.fr.
1158 +   Changes by Michael Meissner, meissner@osf.org.
1159 +   64-bit r4000 support by Ian Lance Taylor, ian@cygnus.com, and
1160 +   Brendan Eich, brendan@microunity.com.
1161 +
1162 +This file is part of GCC.
1163 +
1164 +GCC is free software; you can redistribute it and/or modify
1165 +it under the terms of the GNU General Public License as published by
1166 +the Free Software Foundation; either version 3, or (at your option)
1167 +any later version.
1168 +
1169 +GCC is distributed in the hope that it will be useful,
1170 +but WITHOUT ANY WARRANTY; without even the implied warranty of
1171 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1172 +GNU General Public License for more details.
1173 +
1174 +You should have received a copy of the GNU General Public License
1175 +along with GCC; see the file COPYING3.  If not see
1176 +<http://www.gnu.org/licenses/>.  */
1177 +
1178 +#include "config.h"
1179 +#include "system.h"
1180 +#include "coretypes.h"
1181 +#include "tm.h"
1182 +#include "rtl.h"
1183 +#include "regs.h"
1184 +#include "hard-reg-set.h"
1185 +#include "insn-config.h"
1186 +#include "conditions.h"
1187 +#include "insn-attr.h"
1188 +#include "recog.h"
1189 +#include "output.h"
1190 +#include "tree.h"
1191 +#include "function.h"
1192 +#include "expr.h"
1193 +#include "optabs.h"
1194 +#include "libfuncs.h"
1195 +#include "flags.h"
1196 +#include "reload.h"
1197 +#include "tm_p.h"
1198 +#include "ggc.h"
1199 +#include "gstab.h"
1200 +#include "hashtab.h"
1201 +#include "debug.h"
1202 +#include "target.h"
1203 +#include "target-def.h"
1204 +#include "integrate.h"
1205 +#include "langhooks.h"
1206 +#include "cfglayout.h"
1207 +#include "sched-int.h"
1208 +#include "gimple.h"
1209 +#include "bitmap.h"
1210 +#include "diagnostic.h"
1211 +#include "target-globals.h"
1212 +#include <stdint.h>
1213 +
1214 +/*----------------------------------------------------------------------*/
1215 +/* RISCV_SYSCFG_VLEN_MAX                                                */
1216 +/*----------------------------------------------------------------------*/
1217 +/* Eventually we want to include syscfg.h here so that we can use the
1218 +   common definition of RISCV_SYSCFG_VLEN_MAX, but for now it is not
1219 +   clear how to do this. syscfg.h in in libgloss which is not used when
1220 +   building the actual cross-compiler. We kind of want to use the
1221 +   "version" in sims - the one for native programs instead of RISC-V
1222 +   programs. Even if we could include syscfg.h though, we would still
1223 +   need to figure out a way to include it in the mips-riscv.md since the
1224 +   machine description file also refers to these modes. */
1225 +
1226 +#define RISCV_SYSCFG_VLEN_MAX 32
1227 +
1228 +/*----------------------------------------------------------------------*/
1229 +/* MIPS_RISCV_VECTOR_MODE_NAME                                          */
1230 +/*----------------------------------------------------------------------*/
1231 +/* This is a helper macro which creates a RISC-V vector mode name from
1232 +   the given inner_mode. It does this by concatenating a 'V' prefix, the
1233 +   maximum RISC-V vector length, and the inner mode together. For
1234 +   example, MIPS_RISCV_VECTOR_MODE_NAME(SI) should expand to V32SI if
1235 +   the RISC-V maximum vector length is 32. We need to use the nested
1236 +   macros to make sure RISCV_SYSCFG_VLEN_MAX is expanded _before_
1237 +   concatenation. */
1238 +
1239 +#define MIPS_RISCV_VECTOR_MODE_NAME_H2( res_ ) res_
1240 +
1241 +#define MIPS_RISCV_VECTOR_MODE_NAME_H1( arg0_, arg1_ ) \
1242 +  MIPS_RISCV_VECTOR_MODE_NAME_H2( V ## arg0_ ## arg1_ ## mode )
1243 +
1244 +#define MIPS_RISCV_VECTOR_MODE_NAME_H0( arg0_, arg1_ ) \
1245 +  MIPS_RISCV_VECTOR_MODE_NAME_H1( arg0_, arg1_ )
1246 +
1247 +#define MIPS_RISCV_VECTOR_MODE_NAME( inner_mode_ ) \
1248 +  MIPS_RISCV_VECTOR_MODE_NAME_H0( RISCV_SYSCFG_VLEN_MAX, inner_mode_ )
1249 +
1250 +/* True if X is an UNSPEC wrapper around a SYMBOL_REF or LABEL_REF.  */
1251 +#define UNSPEC_ADDRESS_P(X)                                    \
1252 +  (GET_CODE (X) == UNSPEC                                      \
1253 +   && XINT (X, 1) >= UNSPEC_ADDRESS_FIRST                      \
1254 +   && XINT (X, 1) < UNSPEC_ADDRESS_FIRST + NUM_SYMBOL_TYPES)
1255 +
1256 +/* Extract the symbol or label from UNSPEC wrapper X.  */
1257 +#define UNSPEC_ADDRESS(X) \
1258 +  XVECEXP (X, 0, 0)
1259 +
1260 +/* Extract the symbol type from UNSPEC wrapper X.  */
1261 +#define UNSPEC_ADDRESS_TYPE(X) \
1262 +  ((enum mips_symbol_type) (XINT (X, 1) - UNSPEC_ADDRESS_FIRST))
1263 +
1264 +/* The maximum distance between the top of the stack frame and the
1265 +   value $sp has when we save and restore registers.
1266 +
1267 +   The value for normal-mode code must be a SMALL_OPERAND and must
1268 +   preserve the maximum stack alignment.  We therefore use a value
1269 +   of 0x7ff0 in this case.
1270 +
1271 +   MIPS16e SAVE and RESTORE instructions can adjust the stack pointer by
1272 +   up to 0x7f8 bytes and can usually save or restore all the registers
1273 +   that we need to save or restore.  (Note that we can only use these
1274 +   instructions for o32, for which the stack alignment is 8 bytes.)
1275 +
1276 +   We use a maximum gap of 0x100 or 0x400 for MIPS16 code when SAVE and
1277 +   RESTORE are not available.  We can then use unextended instructions
1278 +   to save and restore registers, and to allocate and deallocate the top
1279 +   part of the frame.  */
1280 +#define MIPS_MAX_FIRST_STACK_STEP (RISCV_IMM_REACH/2 - 16)
1281 +
1282 +/* True if INSN is a mips.md pattern or asm statement.  */
1283 +#define USEFUL_INSN_P(INSN)                                            \
1284 +  (NONDEBUG_INSN_P (INSN)                                              \
1285 +   && GET_CODE (PATTERN (INSN)) != USE                                 \
1286 +   && GET_CODE (PATTERN (INSN)) != CLOBBER                             \
1287 +   && GET_CODE (PATTERN (INSN)) != ADDR_VEC                            \
1288 +   && GET_CODE (PATTERN (INSN)) != ADDR_DIFF_VEC)
1289 +
1290 +/* True if bit BIT is set in VALUE.  */
1291 +#define BITSET_P(VALUE, BIT) (((VALUE) & (1 << (BIT))) != 0)
1292 +
1293 +/* Classifies an address.
1294 +
1295 +   ADDRESS_REG
1296 +       A natural register + offset address.  The register satisfies
1297 +       mips_valid_base_register_p and the offset is a const_arith_operand.
1298 +
1299 +   ADDRESS_LO_SUM
1300 +       A LO_SUM rtx.  The first operand is a valid base register and
1301 +       the second operand is a symbolic address.
1302 +
1303 +   ADDRESS_CONST_INT
1304 +       A signed 16-bit constant address.
1305 +
1306 +   ADDRESS_SYMBOLIC:
1307 +       A constant symbolic address.  */
1308 +enum mips_address_type {
1309 +  ADDRESS_REG,
1310 +  ADDRESS_LO_SUM,
1311 +  ADDRESS_CONST_INT,
1312 +  ADDRESS_SYMBOLIC
1313 +};
1314 +
1315 +/* Macros to create an enumeration identifier for a function prototype.  */
1316 +#define MIPS_FTYPE_NAME1(A, B) MIPS_##A##_FTYPE_##B
1317 +#define MIPS_FTYPE_NAME2(A, B, C) MIPS_##A##_FTYPE_##B##_##C
1318 +#define MIPS_FTYPE_NAME3(A, B, C, D) MIPS_##A##_FTYPE_##B##_##C##_##D
1319 +#define MIPS_FTYPE_NAME4(A, B, C, D, E) MIPS_##A##_FTYPE_##B##_##C##_##D##_##E
1320 +
1321 +/* Classifies the prototype of a built-in function.  */
1322 +enum mips_function_type {
1323 +#define DEF_MIPS_FTYPE(NARGS, LIST) MIPS_FTYPE_NAME##NARGS LIST,
1324 +#include "config/riscv/riscv-ftypes.def"
1325 +#undef DEF_MIPS_FTYPE
1326 +  MIPS_MAX_FTYPE_MAX
1327 +};
1328 +
1329 +/* Specifies how a built-in function should be converted into rtl.  */
1330 +enum mips_builtin_type {
1331 +  /* The function corresponds directly to an .md pattern.  The return
1332 +     value is mapped to operand 0 and the arguments are mapped to
1333 +     operands 1 and above.  */
1334 +  MIPS_BUILTIN_DIRECT,
1335 +
1336 +  /* The function corresponds directly to an .md pattern.  There is no return
1337 +     value and the arguments are mapped to operands 0 and above.  */
1338 +  MIPS_BUILTIN_DIRECT_NO_TARGET
1339 +};
1340 +
1341 +/* Information about a function's frame layout.  */
1342 +struct GTY(())  mips_frame_info {
1343 +  /* The size of the frame in bytes.  */
1344 +  HOST_WIDE_INT total_size;
1345 +
1346 +  /* Bit X is set if the function saves or restores GPR X.  */
1347 +  unsigned int mask;
1348 +
1349 +  /* Likewise FPR X.  */
1350 +  unsigned int fmask;
1351 +
1352 +  /* Offsets of fixed-point and floating-point save areas from frame bottom */
1353 +  HOST_WIDE_INT gp_sp_offset;
1354 +  HOST_WIDE_INT fp_sp_offset;
1355 +
1356 +  /* Offset of virtual frame pointer from stack pointer/frame bottom */
1357 +  HOST_WIDE_INT frame_pointer_offset;
1358 +
1359 +  /* Offset of hard frame pointer from stack pointer/frame bottom */
1360 +  HOST_WIDE_INT hard_frame_pointer_offset;
1361 +
1362 +  /* The offset of arg_pointer_rtx from the bottom of the frame.  */
1363 +  HOST_WIDE_INT arg_pointer_offset;
1364 +};
1365 +
1366 +struct GTY(())  machine_function {
1367 +  /* The number of extra stack bytes taken up by register varargs.
1368 +     This area is allocated by the callee at the very top of the frame.  */
1369 +  int varargs_size;
1370 +
1371 +  /* The current frame information, calculated by mips_compute_frame_info.  */
1372 +  struct mips_frame_info frame;
1373 +};
1374 +
1375 +/* Information about a single argument.  */
1376 +struct mips_arg_info {
1377 +  /* True if the argument is passed in a floating-point register, or
1378 +     would have been if we hadn't run out of registers.  */
1379 +  bool fpr_p;
1380 +
1381 +  /* The number of words passed in registers, rounded up.  */
1382 +  unsigned int reg_words;
1383 +
1384 +  /* For EABI, the offset of the first register from GP_ARG_FIRST or
1385 +     FP_ARG_FIRST.  For other ABIs, the offset of the first register from
1386 +     the start of the ABI's argument structure (see the CUMULATIVE_ARGS
1387 +     comment for details).
1388 +
1389 +     The value is MAX_ARGS_IN_REGISTERS if the argument is passed entirely
1390 +     on the stack.  */
1391 +  unsigned int reg_offset;
1392 +
1393 +  /* The number of words that must be passed on the stack, rounded up.  */
1394 +  unsigned int stack_words;
1395 +
1396 +  /* The offset from the start of the stack overflow area of the argument's
1397 +     first stack word.  Only meaningful when STACK_WORDS is nonzero.  */
1398 +  unsigned int stack_offset;
1399 +};
1400 +
1401 +/* Information about an address described by mips_address_type.
1402 +
1403 +   ADDRESS_CONST_INT
1404 +       No fields are used.
1405 +
1406 +   ADDRESS_REG
1407 +       REG is the base register and OFFSET is the constant offset.
1408 +
1409 +   ADDRESS_LO_SUM
1410 +       REG and OFFSET are the operands to the LO_SUM and SYMBOL_TYPE
1411 +       is the type of symbol it references.
1412 +
1413 +   ADDRESS_SYMBOLIC
1414 +       SYMBOL_TYPE is the type of symbol that the address references.  */
1415 +struct mips_address_info {
1416 +  enum mips_address_type type;
1417 +  rtx reg;
1418 +  rtx offset;
1419 +  enum mips_symbol_type symbol_type;
1420 +};
1421 +
1422 +/* One stage in a constant building sequence.  These sequences have
1423 +   the form:
1424 +
1425 +       A = VALUE[0]
1426 +       A = A CODE[1] VALUE[1]
1427 +       A = A CODE[2] VALUE[2]
1428 +       ...
1429 +
1430 +   where A is an accumulator, each CODE[i] is a binary rtl operation
1431 +   and each VALUE[i] is a constant integer.  CODE[0] is undefined.  */
1432 +struct mips_integer_op {
1433 +  enum rtx_code code;
1434 +  unsigned HOST_WIDE_INT value;
1435 +};
1436 +
1437 +/* The largest number of operations needed to load an integer constant.
1438 +   The worst accepted case for 64-bit constants is LUI,ORI,SLL,ORI,SLL,ORI.
1439 +   When the lowest bit is clear, we can try, but reject a sequence with
1440 +   an extra SLL at the end.  */
1441 +#define MIPS_MAX_INTEGER_OPS 32
1442 +
1443 +/* Costs of various operations on the different architectures.  */
1444 +
1445 +struct mips_rtx_cost_data
1446 +{
1447 +  unsigned short fp_add;
1448 +  unsigned short fp_mult_sf;
1449 +  unsigned short fp_mult_df;
1450 +  unsigned short fp_div_sf;
1451 +  unsigned short fp_div_df;
1452 +  unsigned short int_mult_si;
1453 +  unsigned short int_mult_di;
1454 +  unsigned short int_div_si;
1455 +  unsigned short int_div_di;
1456 +  unsigned short branch_cost;
1457 +  unsigned short memory_latency;
1458 +};
1459 +
1460 +/* Global variables for machine-dependent things.  */
1461 +
1462 +/* The number of file directives written by mips_output_filename.  */
1463 +int num_source_filenames;
1464 +
1465 +/* The name that appeared in the last .file directive written by
1466 +   mips_output_filename, or "" if mips_output_filename hasn't
1467 +   written anything yet.  */
1468 +const char *current_function_file = "";
1469 +
1470 +/* Arrays that map GCC register numbers to debugger register numbers.  */
1471 +int mips_dbx_regno[FIRST_PSEUDO_REGISTER];
1472 +int mips_dwarf_regno[FIRST_PSEUDO_REGISTER];
1473 +
1474 +/* The processor that we should tune the code for.  */
1475 +enum processor mips_tune;
1476 +
1477 +/* Which cost information to use.  */
1478 +static const struct mips_rtx_cost_data *mips_cost;
1479 +
1480 +/* Index [M][R] is true if register R is allowed to hold a value of mode M.  */
1481 +bool mips_hard_regno_mode_ok[(int) MAX_MACHINE_MODE][FIRST_PSEUDO_REGISTER];
1482 +
1483 +static GTY (()) int mips_output_filename_first_time = 1;
1484 +
1485 +/* mips_split_p[X] is true if symbols of type X can be split by
1486 +   mips_split_symbol.  */
1487 +bool mips_split_p[NUM_SYMBOL_TYPES];
1488 +
1489 +/* mips_lo_relocs[X] is the relocation to use when a symbol of type X
1490 +   appears in a LO_SUM.  It can be null if such LO_SUMs aren't valid or
1491 +   if they are matched by a special .md file pattern.  */
1492 +static const char *mips_lo_relocs[NUM_SYMBOL_TYPES];
1493 +
1494 +/* Likewise for HIGHs.  */
1495 +static const char *mips_hi_relocs[NUM_SYMBOL_TYPES];
1496 +
1497 +/* Target state for MIPS16.  */
1498 +struct target_globals *mips16_globals;
1499 +
1500 +/* Index R is the smallest register class that contains register R.  */
1501 +const enum reg_class mips_regno_to_class[FIRST_PSEUDO_REGISTER] = {
1502 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
1503 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
1504 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
1505 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
1506 +  GR_REGS,     V1_REG,         GR_REGS,        GR_REGS,
1507 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
1508 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
1509 +  GR_REGS,     GR_REGS,        GR_REGS,        GR_REGS,
1510 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
1511 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
1512 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
1513 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
1514 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
1515 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
1516 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
1517 +  FP_REGS,     FP_REGS,        FP_REGS,        FP_REGS,
1518 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
1519 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
1520 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
1521 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
1522 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
1523 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
1524 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
1525 +  VEC_GR_REGS, VEC_GR_REGS,    VEC_GR_REGS,    VEC_GR_REGS,
1526 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
1527 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
1528 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
1529 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
1530 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
1531 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
1532 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
1533 +  VEC_FP_REGS, VEC_FP_REGS,    VEC_FP_REGS,    VEC_FP_REGS,
1534 +  FRAME_REGS,  FRAME_REGS,     NO_REGS,        NO_REGS,
1535 +};
1536 +
1537 +/* The value of TARGET_ATTRIBUTE_TABLE.  */
1538 +static const struct attribute_spec mips_attribute_table[] = {
1539 +  /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1540 +  { "long_call",   0, 0, false, true,  true,  NULL },
1541 +  { "far",                0, 0, false, true,  true,  NULL },
1542 +  { "near",        0, 0, false, true,  true,  NULL },
1543 +  { "utfunc",      0, 0, true,  false, false, NULL },
1544 +  { NULL,         0, 0, false, false, false, NULL }
1545 +};
1546 +\f
1547 +/* A table describing all the processors GCC knows about.  Names are
1548 +   matched in the order listed.  The first mention of an ISA level is
1549 +   taken as the canonical name for that ISA.
1550 +
1551 +   To ease comparison, please keep this table in the same order
1552 +   as GAS's mips_cpu_info_table.  Please also make sure that
1553 +   MIPS_ISA_LEVEL_SPEC and MIPS_ARCH_FLOAT_SPEC handle all -march
1554 +   options correctly.  */
1555 +static const struct mips_cpu_info mips_cpu_info_table[] = {
1556 +  /* Entries for generic ISAs.  */
1557 +  { "rocket", PROCESSOR_ROCKET, 0 },
1558 +};
1559 +
1560 +/* Default costs.  If these are used for a processor we should look
1561 +   up the actual costs.  */
1562 +#define DEFAULT_COSTS COSTS_N_INSNS (8),  /* fp_add */       \
1563 +                      COSTS_N_INSNS (8),  /* fp_mult_sf */   \
1564 +                      COSTS_N_INSNS (8),  /* fp_mult_df */   \
1565 +                      COSTS_N_INSNS (20), /* fp_div_sf */    \
1566 +                      COSTS_N_INSNS (20), /* fp_div_df */    \
1567 +                      COSTS_N_INSNS (10), /* int_mult_si */  \
1568 +                      COSTS_N_INSNS (10), /* int_mult_di */  \
1569 +                      COSTS_N_INSNS (69), /* int_div_si */   \
1570 +                      COSTS_N_INSNS (69), /* int_div_di */   \
1571 +                                       2, /* branch_cost */  \
1572 +                                       7  /* memory_latency */
1573 +
1574 +/* Floating-point costs for processors without an FPU.  Just assume that
1575 +   all floating-point libcalls are very expensive.  */
1576 +#define SOFT_FP_COSTS COSTS_N_INSNS (256), /* fp_add */       \
1577 +                      COSTS_N_INSNS (256), /* fp_mult_sf */   \
1578 +                      COSTS_N_INSNS (256), /* fp_mult_df */   \
1579 +                      COSTS_N_INSNS (256), /* fp_div_sf */    \
1580 +                      COSTS_N_INSNS (256)  /* fp_div_df */
1581 +
1582 +/* Costs to use when optimizing for size.  */
1583 +static const struct mips_rtx_cost_data mips_rtx_cost_optimize_size = {
1584 +  COSTS_N_INSNS (1),            /* fp_add */
1585 +  COSTS_N_INSNS (1),            /* fp_mult_sf */
1586 +  COSTS_N_INSNS (1),            /* fp_mult_df */
1587 +  COSTS_N_INSNS (1),            /* fp_div_sf */
1588 +  COSTS_N_INSNS (1),            /* fp_div_df */
1589 +  COSTS_N_INSNS (1),            /* int_mult_si */
1590 +  COSTS_N_INSNS (1),            /* int_mult_di */
1591 +  COSTS_N_INSNS (1),            /* int_div_si */
1592 +  COSTS_N_INSNS (1),            /* int_div_di */
1593 +                  2,           /* branch_cost */
1594 +                  4            /* memory_latency */
1595 +};
1596 +
1597 +/* Costs to use when optimizing for speed, indexed by processor.  */
1598 +static const struct mips_rtx_cost_data
1599 +  mips_rtx_cost_data[NUM_PROCESSOR_VALUES] = {
1600 +  { /* Rocket */ DEFAULT_COSTS},
1601 +};
1602 +\f
1603 +static int mips_register_move_cost (enum machine_mode, reg_class_t,
1604 +                                   reg_class_t);
1605 +static unsigned int mips_function_arg_boundary (enum machine_mode, const_tree);
1606 +
1607 +/* Predicates to test for presence of "near" and "far"/"long_call"
1608 +   attributes on the given TYPE.  */
1609 +
1610 +static bool
1611 +mips_near_type_p (const_tree type)
1612 +{
1613 +  return lookup_attribute ("near", TYPE_ATTRIBUTES (type)) != NULL;
1614 +}
1615 +
1616 +static bool
1617 +mips_far_type_p (const_tree type)
1618 +{
1619 +  return (lookup_attribute ("long_call", TYPE_ATTRIBUTES (type)) != NULL
1620 +         || lookup_attribute ("far", TYPE_ATTRIBUTES (type)) != NULL);
1621 +}
1622 +
1623 +/* Implement TARGET_COMP_TYPE_ATTRIBUTES.  */
1624 +
1625 +static int
1626 +mips_comp_type_attributes (const_tree type1, const_tree type2)
1627 +{
1628 +  /* Disallow mixed near/far attributes.  */
1629 +  if (mips_far_type_p (type1) && mips_near_type_p (type2))
1630 +    return 0;
1631 +  if (mips_near_type_p (type1) && mips_far_type_p (type2))
1632 +    return 0;
1633 +  return 1;
1634 +}
1635 +
1636 +/* If X is a PLUS of a CONST_INT, return the two terms in *BASE_PTR
1637 +   and *OFFSET_PTR.  Return X in *BASE_PTR and 0 in *OFFSET_PTR otherwise.  */
1638 +
1639 +static void
1640 +mips_split_plus (rtx x, rtx *base_ptr, HOST_WIDE_INT *offset_ptr)
1641 +{
1642 +  if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
1643 +    {
1644 +      *base_ptr = XEXP (x, 0);
1645 +      *offset_ptr = INTVAL (XEXP (x, 1));
1646 +    }
1647 +  else
1648 +    {
1649 +      *base_ptr = x;
1650 +      *offset_ptr = 0;
1651 +    }
1652 +}
1653 +
1654 +/* Fill CODES with a sequence of rtl operations to load VALUE.
1655 +   Return the number of operations needed.  */
1656 +
1657 +static int
1658 +riscv_build_integer_simple (struct mips_integer_op *codes, HOST_WIDE_INT value)
1659 +{
1660 +  HOST_WIDE_INT low_part = RISCV_CONST_LOW_PART (value);
1661 +  int cost = INT_MAX, alt_cost;
1662 +  struct mips_integer_op alt_codes[MIPS_MAX_INTEGER_OPS];
1663 +
1664 +  if (SMALL_OPERAND (value) || LUI_OPERAND (value))
1665 +    {
1666 +      /* Simply ADDI or LUI */
1667 +      codes[0].code = UNKNOWN;
1668 +      codes[0].value = value;
1669 +      return 1;
1670 +    }
1671 +
1672 +  /* End with ADDI */
1673 +  if (low_part != 0)
1674 +    {
1675 +      cost = 1 + riscv_build_integer_simple (codes, value - low_part);
1676 +      codes[cost-1].code = PLUS;
1677 +      codes[cost-1].value = low_part;
1678 +    }
1679 +
1680 +  /* End with XORI */
1681 +  if (low_part < 0)
1682 +    {
1683 +      alt_cost = 1 + riscv_build_integer_simple (alt_codes, value ^ low_part);
1684 +      alt_codes[alt_cost-1].code = XOR;
1685 +      alt_codes[alt_cost-1].value = low_part;
1686 +      if (alt_cost < cost)
1687 +       cost = alt_cost, memcpy (codes, alt_codes, sizeof(alt_codes));
1688 +    }
1689 +
1690 +  /* Eliminate trailing zeros and end with SLLI */
1691 +  if ((value & 1) == 0)
1692 +    {
1693 +      int shift = __builtin_ctzl(value);
1694 +      alt_cost = 1 + riscv_build_integer_simple (alt_codes, value >> shift);
1695 +      alt_codes[alt_cost-1].code = ASHIFT;
1696 +      alt_codes[alt_cost-1].value = shift;
1697 +      if (alt_cost < cost)
1698 +       cost = alt_cost, memcpy (codes, alt_codes, sizeof(alt_codes));
1699 +    }
1700 +
1701 +  gcc_assert (cost <= MIPS_MAX_INTEGER_OPS);
1702 +  return cost;
1703 +}
1704 +
1705 +static int
1706 +riscv_build_integer (struct mips_integer_op *codes, HOST_WIDE_INT value)
1707 +{
1708 +  int cost = riscv_build_integer_simple (codes, value);
1709 +
1710 +  /* Eliminate leading zeros and end with SRLI */
1711 +  if (value > 0 && cost > 2)
1712 +    {
1713 +      struct mips_integer_op alt_codes[MIPS_MAX_INTEGER_OPS];
1714 +      int alt_cost, shift;
1715 +
1716 +      shift = __builtin_clzl(value);
1717 +      alt_cost = 1 + riscv_build_integer_simple (alt_codes, value << shift);
1718 +      alt_codes[alt_cost-1].code = LSHIFTRT;
1719 +      alt_codes[alt_cost-1].value = shift;
1720 +      if (alt_cost < cost)
1721 +       cost = alt_cost, memcpy (codes, alt_codes, sizeof(alt_codes));
1722 +
1723 +      /* Also try filling discarded bits with 1s */
1724 +      shift = __builtin_clzl(value);
1725 +      alt_cost = 1 + riscv_build_integer_simple (alt_codes,
1726 +                       value << shift | ((1L<<shift)-1));
1727 +      alt_codes[alt_cost-1].code = LSHIFTRT;
1728 +      alt_codes[alt_cost-1].value = shift;
1729 +      if (alt_cost < cost)
1730 +       cost = alt_cost, memcpy (codes, alt_codes, sizeof(alt_codes));
1731 +    }
1732 +
1733 +  return cost;
1734 +}
1735 +
1736 +/* Return true if X is a thread-local symbol.  */
1737 +
1738 +static bool
1739 +mips_tls_symbol_p (const_rtx x)
1740 +{
1741 +  return GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (x) != 0;
1742 +}
1743 +
1744 +bool
1745 +riscv_symbol_binds_local_p (const_rtx x)
1746 +{
1747 +  if (SYMBOL_REF_DECL (x))
1748 +    {
1749 +      if (DECL_BUILT_IN_CLASS (SYMBOL_REF_DECL (x)))
1750 +       return true; /* Force local binding of memset etc. */
1751 +      return targetm.binds_local_p (SYMBOL_REF_DECL (x));
1752 +    }
1753 +  return SYMBOL_REF_LOCAL_P (x);
1754 +}
1755 +
1756 +/* Return the method that should be used to access SYMBOL_REF or
1757 +   LABEL_REF X in context CONTEXT.  */
1758 +
1759 +static enum mips_symbol_type
1760 +mips_classify_symbol (const_rtx x)
1761 +{
1762 +  if (mips_tls_symbol_p (x))
1763 +    return SYMBOL_TLS;
1764 +  return SYMBOL_ABSOLUTE;
1765 +}
1766 +
1767 +/* Classify the base of symbolic expression X, given that X appears in
1768 +   context CONTEXT.  */
1769 +
1770 +static enum mips_symbol_type
1771 +mips_classify_symbolic_expression (rtx x)
1772 +{
1773 +  rtx offset;
1774 +
1775 +  split_const (x, &x, &offset);
1776 +  if (UNSPEC_ADDRESS_P (x))
1777 +    return UNSPEC_ADDRESS_TYPE (x);
1778 +
1779 +  return mips_classify_symbol (x);
1780 +}
1781 +
1782 +/* Return true if OFFSET is within the range [0, ALIGN), where ALIGN
1783 +   is the alignment in bytes of SYMBOL_REF X.  */
1784 +
1785 +static bool
1786 +mips_offset_within_alignment_p (rtx x, HOST_WIDE_INT offset)
1787 +{
1788 +  HOST_WIDE_INT align;
1789 +
1790 +  align = SYMBOL_REF_DECL (x) ? DECL_ALIGN_UNIT (SYMBOL_REF_DECL (x)) : 1;
1791 +  return IN_RANGE (offset, 0, align - 1);
1792 +}
1793 +
1794 +/* Return true if X is a symbolic constant that can be used in context
1795 +   CONTEXT.  If it is, store the type of the symbol in *SYMBOL_TYPE.  */
1796 +
1797 +bool
1798 +mips_symbolic_constant_p (rtx x, enum mips_symbol_type *symbol_type)
1799 +{
1800 +  rtx offset;
1801 +
1802 +  split_const (x, &x, &offset);
1803 +  if (UNSPEC_ADDRESS_P (x))
1804 +    {
1805 +      *symbol_type = UNSPEC_ADDRESS_TYPE (x);
1806 +      x = UNSPEC_ADDRESS (x);
1807 +    }
1808 +  else if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
1809 +    *symbol_type = mips_classify_symbol (x);
1810 +  else
1811 +    return false;
1812 +
1813 +  if (offset == const0_rtx)
1814 +    return true;
1815 +
1816 +  if (flag_pic)
1817 +  /* Load the base address from the GOT, then add the offset. The offset
1818 +     calculation can usually be folded into the load or store instruction. */
1819 +    return false;
1820 +
1821 +  /* Check whether a nonzero offset is valid for the underlying
1822 +     relocations.  */
1823 +  switch (*symbol_type)
1824 +    {
1825 +    case SYMBOL_ABSOLUTE:
1826 +      /* If the target has 64-bit pointers and the object file only
1827 +        supports 32-bit symbols, the values of those symbols will be
1828 +        sign-extended.  In this case we can't allow an arbitrary offset
1829 +        in case the 32-bit value X + OFFSET has a different sign from X.  */
1830 +      return Pmode == SImode || offset_within_block_p (x, INTVAL (offset));
1831 +
1832 +    case SYMBOL_TPREL:
1833 +      /* There is no carry between the HI and LO REL relocations, so the
1834 +        offset is only valid if we know it won't lead to such a carry.  */
1835 +      return mips_offset_within_alignment_p (x, INTVAL (offset));
1836 +
1837 +    case SYMBOL_TLS:
1838 +      return false;
1839 +    }
1840 +  gcc_unreachable ();
1841 +}
1842 +\f
1843 +/* Like mips_symbol_insns, but treat extended MIPS16 instructions as a
1844 +   single instruction.  We rely on the fact that, in the worst case,
1845 +   all instructions involved in a MIPS16 address calculation are usually
1846 +   extended ones.  */
1847 +
1848 +static int
1849 +mips_symbol_insns (enum mips_symbol_type type, enum machine_mode mode)
1850 +{
1851 +  switch (type)
1852 +    {
1853 +    case SYMBOL_ABSOLUTE:
1854 +    case SYMBOL_TPREL:
1855 +      /* One of LUI or AUIPC, followed by one of ADDI, LD, or LW. */
1856 +      return 2;
1857 +
1858 +    case SYMBOL_TLS:
1859 +      /* We don't treat a bare TLS symbol as a constant.  */
1860 +      return 0;
1861 +    }
1862 +  gcc_unreachable ();
1863 +}
1864 +
1865 +/* A for_each_rtx callback.  Stop the search if *X references a
1866 +   thread-local symbol.  */
1867 +
1868 +static int
1869 +mips_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
1870 +{
1871 +  return mips_tls_symbol_p (*x);
1872 +}
1873 +
1874 +/* Implement TARGET_CANNOT_FORCE_CONST_MEM.  */
1875 +
1876 +static bool
1877 +mips_cannot_force_const_mem (rtx x)
1878 +{
1879 +  enum mips_symbol_type type;
1880 +  rtx base, offset;
1881 +
1882 +  /* There is no assembler syntax for expressing an address-sized
1883 +     high part.  */
1884 +  if (GET_CODE (x) == HIGH)
1885 +    return true;
1886 +
1887 +  /* As an optimization, reject constants that mips_legitimize_move
1888 +     can expand inline.
1889 +
1890 +     Suppose we have a multi-instruction sequence that loads constant C
1891 +     into register R.  If R does not get allocated a hard register, and
1892 +     R is used in an operand that allows both registers and memory
1893 +     references, reload will consider forcing C into memory and using
1894 +     one of the instruction's memory alternatives.  Returning false
1895 +     here will force it to use an input reload instead.  */
1896 +  if (CONST_INT_P (x) && LEGITIMATE_CONSTANT_P (x))
1897 +    return true;
1898 +
1899 +  split_const (x, &base, &offset);
1900 +  if (mips_symbolic_constant_p (base, &type))
1901 +    {
1902 +      /* The same optimization as for CONST_INT.  */
1903 +      if (SMALL_INT (offset) && mips_symbol_insns (type, MAX_MACHINE_MODE) > 0)
1904 +       return true;
1905 +    }
1906 +
1907 +  /* TLS symbols must be computed by mips_legitimize_move.  */
1908 +  if (for_each_rtx (&x, &mips_tls_symbol_ref_1, NULL))
1909 +    return true;
1910 +
1911 +  return false;
1912 +}
1913 +
1914 +/* Return true if register REGNO is a valid base register for mode MODE.
1915 +   STRICT_P is true if REG_OK_STRICT is in effect.  */
1916 +
1917 +int
1918 +mips_regno_mode_ok_for_base_p (int regno, enum machine_mode mode ATTRIBUTE_UNUSED,
1919 +                              bool strict_p)
1920 +{
1921 +  if (!HARD_REGISTER_NUM_P (regno))
1922 +    {
1923 +      if (!strict_p)
1924 +       return true;
1925 +      regno = reg_renumber[regno];
1926 +    }
1927 +
1928 +  /* These fake registers will be eliminated to either the stack or
1929 +     hard frame pointer, both of which are usually valid base registers.
1930 +     Reload deals with the cases where the eliminated form isn't valid.  */
1931 +  if (regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM)
1932 +    return true;
1933 +
1934 +  return GP_REG_P (regno);
1935 +}
1936 +
1937 +/* Return true if X is a valid base register for mode MODE.
1938 +   STRICT_P is true if REG_OK_STRICT is in effect.  */
1939 +
1940 +static bool
1941 +mips_valid_base_register_p (rtx x, enum machine_mode mode, bool strict_p)
1942 +{
1943 +  if (!strict_p && GET_CODE (x) == SUBREG)
1944 +    x = SUBREG_REG (x);
1945 +
1946 +  return (REG_P (x)
1947 +         && mips_regno_mode_ok_for_base_p (REGNO (x), mode, strict_p));
1948 +}
1949 +
1950 +/* Return true if, for every base register BASE_REG, (plus BASE_REG X)
1951 +   can address a value of mode MODE.  */
1952 +
1953 +static bool
1954 +mips_valid_offset_p (rtx x, enum machine_mode mode)
1955 +{
1956 +  /* Check that X is a signed 12-bit number.  */
1957 +  if (!const_arith_operand (x, Pmode))
1958 +    return false;
1959 +
1960 +  /* We may need to split multiword moves, so make sure that every word
1961 +     is accessible.  */
1962 +  if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
1963 +      && !SMALL_OPERAND (INTVAL (x) + GET_MODE_SIZE (mode) - UNITS_PER_WORD))
1964 +    return false;
1965 +
1966 +  return true;
1967 +}
1968 +
1969 +/* Return true if a LO_SUM can address a value of mode MODE when the
1970 +   LO_SUM symbol has type SYMBOL_TYPE.  */
1971 +
1972 +static bool
1973 +mips_valid_lo_sum_p (enum mips_symbol_type symbol_type, enum machine_mode mode)
1974 +{
1975 +  /* Check that symbols of type SYMBOL_TYPE can be used to access values
1976 +     of mode MODE.  */
1977 +  if (mips_symbol_insns (symbol_type, mode) == 0)
1978 +    return false;
1979 +
1980 +  /* Check that there is a known low-part relocation.  */
1981 +  if (mips_lo_relocs[symbol_type] == NULL)
1982 +    return false;
1983 +
1984 +  /* We may need to split multiword moves, so make sure that each word
1985 +     can be accessed without inducing a carry.  This is mainly needed
1986 +     for o64, which has historically only guaranteed 64-bit alignment
1987 +     for 128-bit types.  */
1988 +  if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
1989 +      && GET_MODE_BITSIZE (mode) > GET_MODE_ALIGNMENT (mode))
1990 +    return false;
1991 +
1992 +  return true;
1993 +}
1994 +
1995 +/* Return true if X is a valid address for machine mode MODE.  If it is,
1996 +   fill in INFO appropriately.  STRICT_P is true if REG_OK_STRICT is in
1997 +   effect.  */
1998 +
1999 +static bool
2000 +mips_classify_address (struct mips_address_info *info, rtx x,
2001 +                      enum machine_mode mode, bool strict_p)
2002 +{
2003 +  switch (GET_CODE (x))
2004 +    {
2005 +    case REG:
2006 +    case SUBREG:
2007 +      info->type = ADDRESS_REG;
2008 +      info->reg = x;
2009 +      info->offset = const0_rtx;
2010 +      return mips_valid_base_register_p (info->reg, mode, strict_p);
2011 +
2012 +    case PLUS:
2013 +      info->type = ADDRESS_REG;
2014 +      info->reg = XEXP (x, 0);
2015 +      info->offset = XEXP (x, 1);
2016 +      return (mips_valid_base_register_p (info->reg, mode, strict_p)
2017 +             && mips_valid_offset_p (info->offset, mode));
2018 +
2019 +    case LO_SUM:
2020 +      info->type = ADDRESS_LO_SUM;
2021 +      info->reg = XEXP (x, 0);
2022 +      info->offset = XEXP (x, 1);
2023 +      /* We have to trust the creator of the LO_SUM to do something vaguely
2024 +        sane.  Target-independent code that creates a LO_SUM should also
2025 +        create and verify the matching HIGH.  Target-independent code that
2026 +        adds an offset to a LO_SUM must prove that the offset will not
2027 +        induce a carry.  Failure to do either of these things would be
2028 +        a bug, and we are not required to check for it here.  The MIPS
2029 +        backend itself should only create LO_SUMs for valid symbolic
2030 +        constants, with the high part being either a HIGH or a copy
2031 +        of _gp. */
2032 +      info->symbol_type
2033 +       = mips_classify_symbolic_expression (info->offset);
2034 +      return (mips_valid_base_register_p (info->reg, mode, strict_p)
2035 +             && mips_valid_lo_sum_p (info->symbol_type, mode));
2036 +
2037 +    case CONST_INT:
2038 +      /* Small-integer addresses don't occur very often, but they
2039 +        are legitimate if $0 is a valid base register.  */
2040 +      info->type = ADDRESS_CONST_INT;
2041 +      return SMALL_INT (x);
2042 +
2043 +    case CONST:
2044 +    case LABEL_REF:
2045 +    case SYMBOL_REF:
2046 +      info->type = ADDRESS_SYMBOLIC;
2047 +      return false;
2048 +
2049 +    default:
2050 +      return false;
2051 +    }
2052 +}
2053 +
2054 +/* Implement TARGET_LEGITIMATE_ADDRESS_P.  */
2055 +
2056 +static bool
2057 +mips_legitimate_address_p (enum machine_mode mode, rtx x, bool strict_p)
2058 +{
2059 +  struct mips_address_info addr;
2060 +
2061 +  return mips_classify_address (&addr, x, mode, strict_p);
2062 +}
2063 +
2064 +/* Return the number of instructions needed to load or store a value
2065 +   of mode MODE at address X.  Return 0 if X isn't valid for MODE.
2066 +   Assume that multiword moves may need to be split into word moves
2067 +   if MIGHT_SPLIT_P, otherwise assume that a single load or store is
2068 +   enough.
2069 +
2070 +   For MIPS16 code, count extended instructions as two instructions.  */
2071 +
2072 +int
2073 +mips_address_insns (rtx x, enum machine_mode mode, bool might_split_p)
2074 +{
2075 +  struct mips_address_info addr;
2076 +
2077 +  if (mips_classify_address (&addr, x, mode, false))
2078 +    {
2079 +      int factor = 1;
2080 +
2081 +      /* BLKmode is used for single unaligned loads and stores and should
2082 +         not count as a multiword mode. */
2083 +      if (mode != BLKmode && might_split_p)
2084 +        factor = (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
2085 +
2086 +      if (addr.type == ADDRESS_SYMBOLIC)
2087 +       factor *= mips_symbol_insns (addr.symbol_type, mode);
2088 +
2089 +      return factor;
2090 +    }
2091 +
2092 +  return 0;
2093 +}
2094 +
2095 +/* Return the number of instructions needed to load constant X.
2096 +   Return 0 if X isn't a valid constant.  */
2097 +
2098 +int
2099 +mips_const_insns (rtx x)
2100 +{
2101 +  struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
2102 +  enum mips_symbol_type symbol_type;
2103 +  rtx offset;
2104 +
2105 +  switch (GET_CODE (x))
2106 +    {
2107 +    case HIGH:
2108 +      if (!mips_symbolic_constant_p (XEXP (x, 0), &symbol_type)
2109 +         || !mips_split_p[symbol_type])
2110 +       return 0;
2111 +
2112 +      /* This is simply an LUI. */
2113 +      return 1;
2114 +
2115 +    case CONST_INT:
2116 +      return riscv_build_integer (codes, INTVAL (x));
2117 +
2118 +    case CONST_DOUBLE:
2119 +    case CONST_VECTOR:
2120 +      /* Allow zeros for normal mode, where we can use $0.  */
2121 +      return x == CONST0_RTX (GET_MODE (x)) ? 1 : 0;
2122 +
2123 +    case CONST:
2124 +      /* See if we can refer to X directly.  */
2125 +      if (mips_symbolic_constant_p (x, &symbol_type))
2126 +       return mips_symbol_insns (symbol_type, MAX_MACHINE_MODE);
2127 +
2128 +      /* Otherwise try splitting the constant into a base and offset.
2129 +        If the offset is a 16-bit value, we can load the base address
2130 +        into a register and then use (D)ADDIU to add in the offset.
2131 +        If the offset is larger, we can load the base and offset
2132 +        into separate registers and add them together with (D)ADDU.
2133 +        However, the latter is only possible before reload; during
2134 +        and after reload, we must have the option of forcing the
2135 +        constant into the pool instead.  */
2136 +      split_const (x, &x, &offset);
2137 +      if (offset != 0)
2138 +       {
2139 +         int n = mips_const_insns (x);
2140 +         if (n != 0)
2141 +           {
2142 +             if (SMALL_INT (offset))
2143 +               return n + 1;
2144 +             else if (!targetm.cannot_force_const_mem (x))
2145 +               return n + 1 + riscv_build_integer (codes, INTVAL (offset));
2146 +           }
2147 +       }
2148 +      return 0;
2149 +
2150 +    case SYMBOL_REF:
2151 +    case LABEL_REF:
2152 +      return mips_symbol_insns (mips_classify_symbol (x), MAX_MACHINE_MODE);
2153 +
2154 +    default:
2155 +      return 0;
2156 +    }
2157 +}
2158 +
2159 +/* X is a doubleword constant that can be handled by splitting it into
2160 +   two words and loading each word separately.  Return the number of
2161 +   instructions required to do this.  */
2162 +
2163 +int
2164 +mips_split_const_insns (rtx x)
2165 +{
2166 +  unsigned int low, high;
2167 +
2168 +  low = mips_const_insns (mips_subword (x, false));
2169 +  high = mips_const_insns (mips_subword (x, true));
2170 +  gcc_assert (low > 0 && high > 0);
2171 +  return low + high;
2172 +}
2173 +
2174 +/* Return the number of instructions needed to implement INSN,
2175 +   given that it loads from or stores to MEM.  Count extended
2176 +   MIPS16 instructions as two instructions.  */
2177 +
2178 +int
2179 +mips_load_store_insns (rtx mem, rtx insn)
2180 +{
2181 +  enum machine_mode mode;
2182 +  bool might_split_p;
2183 +  rtx set;
2184 +
2185 +  gcc_assert (MEM_P (mem));
2186 +  mode = GET_MODE (mem);
2187 +
2188 +  /* Try to prove that INSN does not need to be split.  */
2189 +  might_split_p = true;
2190 +  if (GET_MODE_BITSIZE (mode) == 64)
2191 +    {
2192 +      set = single_set (insn);
2193 +      if (set && !mips_split_64bit_move_p (SET_DEST (set), SET_SRC (set)))
2194 +       might_split_p = false;
2195 +    }
2196 +
2197 +  return mips_address_insns (XEXP (mem, 0), mode, might_split_p);
2198 +}
2199 +
2200 +/* Emit a move from SRC to DEST.  Assume that the move expanders can
2201 +   handle all moves if !can_create_pseudo_p ().  The distinction is
2202 +   important because, unlike emit_move_insn, the move expanders know
2203 +   how to force Pmode objects into the constant pool even when the
2204 +   constant pool address is not itself legitimate.  */
2205 +
2206 +rtx
2207 +mips_emit_move (rtx dest, rtx src)
2208 +{
2209 +  return (can_create_pseudo_p ()
2210 +         ? emit_move_insn (dest, src)
2211 +         : emit_move_insn_1 (dest, src));
2212 +}
2213 +
2214 +/* Emit an instruction of the form (set TARGET (CODE OP0 OP1)).  */
2215 +
2216 +static void
2217 +mips_emit_binary (enum rtx_code code, rtx target, rtx op0, rtx op1)
2218 +{
2219 +  emit_insn (gen_rtx_SET (VOIDmode, target,
2220 +                         gen_rtx_fmt_ee (code, GET_MODE (target), op0, op1)));
2221 +}
2222 +
2223 +/* Compute (CODE OP0 OP1) and store the result in a new register
2224 +   of mode MODE.  Return that new register.  */
2225 +
2226 +static rtx
2227 +mips_force_binary (enum machine_mode mode, enum rtx_code code, rtx op0, rtx op1)
2228 +{
2229 +  rtx reg;
2230 +
2231 +  reg = gen_reg_rtx (mode);
2232 +  mips_emit_binary (code, reg, op0, op1);
2233 +  return reg;
2234 +}
2235 +
2236 +/* Copy VALUE to a register and return that register.  If new pseudos
2237 +   are allowed, copy it into a new register, otherwise use DEST.  */
2238 +
2239 +static rtx
2240 +mips_force_temporary (rtx dest, rtx value)
2241 +{
2242 +  if (can_create_pseudo_p ())
2243 +    return force_reg (Pmode, value);
2244 +  else
2245 +    {
2246 +      mips_emit_move (dest, value);
2247 +      return dest;
2248 +    }
2249 +}
2250 +
2251 +/* Wrap symbol or label BASE in an UNSPEC address of type SYMBOL_TYPE,
2252 +   then add CONST_INT OFFSET to the result.  */
2253 +
2254 +static rtx
2255 +mips_unspec_address_offset (rtx base, rtx offset,
2256 +                           enum mips_symbol_type symbol_type)
2257 +{
2258 +  base = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, base),
2259 +                        UNSPEC_ADDRESS_FIRST + symbol_type);
2260 +  if (offset != const0_rtx)
2261 +    base = gen_rtx_PLUS (Pmode, base, offset);
2262 +  return gen_rtx_CONST (Pmode, base);
2263 +}
2264 +
2265 +/* Return an UNSPEC address with underlying address ADDRESS and symbol
2266 +   type SYMBOL_TYPE.  */
2267 +
2268 +rtx
2269 +mips_unspec_address (rtx address, enum mips_symbol_type symbol_type)
2270 +{
2271 +  rtx base, offset;
2272 +
2273 +  split_const (address, &base, &offset);
2274 +  return mips_unspec_address_offset (base, offset, symbol_type);
2275 +}
2276 +
2277 +/* If OP is an UNSPEC address, return the address to which it refers,
2278 +   otherwise return OP itself.  */
2279 +
2280 +static rtx
2281 +mips_strip_unspec_address (rtx op)
2282 +{
2283 +  rtx base, offset;
2284 +
2285 +  split_const (op, &base, &offset);
2286 +  if (UNSPEC_ADDRESS_P (base))
2287 +    op = plus_constant (UNSPEC_ADDRESS (base), INTVAL (offset));
2288 +  return op;
2289 +}
2290 +
2291 +/* If mips_unspec_address (ADDR, SYMBOL_TYPE) is a 32-bit value, add the
2292 +   high part to BASE and return the result.  Just return BASE otherwise.
2293 +   TEMP is as for mips_force_temporary.
2294 +
2295 +   The returned expression can be used as the first operand to a LO_SUM.  */
2296 +
2297 +static rtx
2298 +mips_unspec_offset_high (rtx temp, rtx base, rtx addr,
2299 +                        enum mips_symbol_type symbol_type)
2300 +{
2301 +  if (mips_split_p[symbol_type])
2302 +    {
2303 +      addr = gen_rtx_HIGH (Pmode, mips_unspec_address (addr, symbol_type));
2304 +      addr = mips_force_temporary (temp, addr);
2305 +      base = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, addr, base));
2306 +    }
2307 +  return base;
2308 +}
2309 +
2310 +/* If MODE is MAX_MACHINE_MODE, ADDR appears as a move operand, otherwise
2311 +   it appears in a MEM of that mode.  Return true if ADDR is a legitimate
2312 +   constant in that context and can be split into high and low parts.
2313 +   If so, and if LOW_OUT is nonnull, emit the high part and store the
2314 +   low part in *LOW_OUT.  Leave *LOW_OUT unchanged otherwise.
2315 +
2316 +   TEMP is as for mips_force_temporary and is used to load the high
2317 +   part into a register.
2318 +
2319 +   When MODE is MAX_MACHINE_MODE, the low part is guaranteed to be
2320 +   a legitimize SET_SRC for an .md pattern, otherwise the low part
2321 +   is guaranteed to be a legitimate address for mode MODE.  */
2322 +
2323 +bool
2324 +mips_split_symbol (rtx temp, rtx addr, enum machine_mode mode, rtx *low_out)
2325 +{
2326 +  enum mips_symbol_type symbol_type;
2327 +  rtx high;
2328 +
2329 +  if (!(GET_CODE (addr) == HIGH && mode == MAX_MACHINE_MODE))
2330 +    {
2331 +      if (mips_symbolic_constant_p (addr, &symbol_type)
2332 +         && mips_symbol_insns (symbol_type, mode) > 0
2333 +         && mips_split_p[symbol_type])
2334 +       {
2335 +         if (low_out)
2336 +           {
2337 +             high = gen_rtx_HIGH (Pmode, copy_rtx (addr));
2338 +             high = mips_force_temporary (temp, high);
2339 +             *low_out = gen_rtx_LO_SUM (Pmode, high, addr);
2340 +           }
2341 +         return true;
2342 +       }
2343 +    }
2344 +  return false;
2345 +}
2346 +
2347 +/* Return a legitimate address for REG + OFFSET.  TEMP is as for
2348 +   mips_force_temporary; it is only needed when OFFSET is not a
2349 +   SMALL_OPERAND.  */
2350 +
2351 +static rtx
2352 +mips_add_offset (rtx temp, rtx reg, HOST_WIDE_INT offset)
2353 +{
2354 +  if (!SMALL_OPERAND (offset))
2355 +    {
2356 +      rtx high;
2357 +
2358 +      /* Leave OFFSET as a 16-bit offset and put the excess in HIGH.
2359 +         The addition inside the macro CONST_HIGH_PART may cause an
2360 +         overflow, so we need to force a sign-extension check.  */
2361 +      high = gen_int_mode (RISCV_CONST_HIGH_PART (offset), Pmode);
2362 +      offset = RISCV_CONST_LOW_PART (offset);
2363 +      high = mips_force_temporary (temp, high);
2364 +      reg = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, high, reg));
2365 +    }
2366 +  return plus_constant (reg, offset);
2367 +}
2368 +
2369 +/* Load an entry from the GOT. */
2370 +static rtx riscv_got_load(rtx dest, rtx sym)
2371 +{
2372 +  return (Pmode == DImode ? gen_got_loaddi(dest, sym) : gen_got_loadsi(dest, sym));
2373 +}
2374 +static rtx riscv_got_load_tls_gd(rtx dest, rtx sym)
2375 +{
2376 +  return (Pmode == DImode ? gen_got_load_tls_gddi(dest, sym) : gen_got_load_tls_gdsi(dest, sym));
2377 +}
2378 +static rtx riscv_got_load_tls_ie(rtx dest, rtx sym)
2379 +{
2380 +  return (Pmode == DImode ? gen_got_load_tls_iedi(dest, sym) : gen_got_load_tls_iesi(dest, sym));
2381 +}
2382 +
2383 +/* The __tls_get_attr symbol.  */
2384 +static GTY(()) rtx mips_tls_symbol;
2385 +
2386 +/* Return an instruction sequence that calls __tls_get_addr.  SYM is
2387 +   the TLS symbol we are referencing and TYPE is the symbol type to use
2388 +   (either global dynamic or local dynamic).  V0 is an RTX for the
2389 +   return value location.  */
2390 +
2391 +static rtx
2392 +mips_call_tls_get_addr (rtx sym, rtx v0)
2393 +{
2394 +  rtx insn, a0;
2395 +
2396 +  a0 = gen_rtx_REG (Pmode, GP_ARG_FIRST);
2397 +
2398 +  if (!mips_tls_symbol)
2399 +    mips_tls_symbol = init_one_libfunc ("__tls_get_addr");
2400 +
2401 +  start_sequence ();
2402 +  
2403 +  emit_insn (riscv_got_load_tls_gd(a0, sym));
2404 +  insn = mips_expand_call (false, v0, mips_tls_symbol, const0_rtx);
2405 +  RTL_CONST_CALL_P (insn) = 1;
2406 +  use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0);
2407 +  insn = get_insns ();
2408 +
2409 +  end_sequence ();
2410 +
2411 +  return insn;
2412 +}
2413 +
2414 +/* Generate the code to access LOC, a thread-local SYMBOL_REF, and return
2415 +   its address.  The return value will be both a valid address and a valid
2416 +   SET_SRC (either a REG or a LO_SUM).  */
2417 +
2418 +static rtx
2419 +mips_legitimize_tls_address (rtx loc)
2420 +{
2421 +  rtx dest, insn, v0, tp, tmp1;
2422 +  enum tls_model model;
2423 +
2424 +  model = SYMBOL_REF_TLS_MODEL (loc);
2425 +  /* Only TARGET_ABICALLS code can have more than one module; other
2426 +     code must be be static and should not use a GOT.  All TLS models
2427 +     reduce to local exec in this situation.  */
2428 +  if (!TARGET_ABICALLS)
2429 +    model = TLS_MODEL_LOCAL_EXEC;
2430 +
2431 +  switch (model)
2432 +    {
2433 +    case TLS_MODEL_LOCAL_DYNAMIC:
2434 +      /* We don't support LDM TLS, so fall through.*/
2435 +    case TLS_MODEL_GLOBAL_DYNAMIC:
2436 +      v0 = gen_rtx_REG (Pmode, GP_RETURN);
2437 +      insn = mips_call_tls_get_addr (loc, v0);
2438 +      dest = gen_reg_rtx (Pmode);
2439 +      emit_libcall_block (insn, dest, v0, loc);
2440 +      break;
2441 +
2442 +    case TLS_MODEL_INITIAL_EXEC:
2443 +      tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM);
2444 +      tmp1 = gen_reg_rtx (Pmode);
2445 +      emit_insn (riscv_got_load_tls_ie(tmp1, loc));
2446 +      dest = gen_reg_rtx (Pmode);
2447 +      emit_insn (gen_add3_insn (dest, tmp1, tp));
2448 +      break;
2449 +
2450 +    case TLS_MODEL_LOCAL_EXEC:
2451 +      tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM);
2452 +      tmp1 = mips_unspec_offset_high (NULL, tp, loc, SYMBOL_TPREL);
2453 +      dest = gen_rtx_LO_SUM (Pmode, tmp1,
2454 +                            mips_unspec_address (loc, SYMBOL_TPREL));
2455 +      break;
2456 +
2457 +    default:
2458 +      gcc_unreachable ();
2459 +    }
2460 +  return dest;
2461 +}
2462 +\f
2463 +/* If X is not a valid address for mode MODE, force it into a register.  */
2464 +
2465 +static rtx
2466 +mips_force_address (rtx x, enum machine_mode mode)
2467 +{
2468 +  if (!mips_legitimate_address_p (mode, x, false))
2469 +    x = force_reg (Pmode, x);
2470 +  return x;
2471 +}
2472 +
2473 +/* This function is used to implement LEGITIMIZE_ADDRESS.  If X can
2474 +   be legitimized in a way that the generic machinery might not expect,
2475 +   return a new address, otherwise return NULL.  MODE is the mode of
2476 +   the memory being accessed.  */
2477 +
2478 +static rtx
2479 +mips_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
2480 +                        enum machine_mode mode)
2481 +{
2482 +  rtx addr;
2483 +
2484 +  if (mips_tls_symbol_p (x))
2485 +    return mips_legitimize_tls_address (x);
2486 +
2487 +  /* See if the address can split into a high part and a LO_SUM.  */
2488 +  if (mips_split_symbol (NULL, x, mode, &addr))
2489 +    return mips_force_address (addr, mode);
2490 +
2491 +  /* Handle BASE + OFFSET using mips_add_offset.  */
2492 +  if (GET_CODE (x) == PLUS && CONST_INT_P (XEXP (x, 1))
2493 +      && INTVAL (XEXP (x, 1)) != 0)
2494 +    {
2495 +      rtx base = XEXP (x, 0);
2496 +      HOST_WIDE_INT offset = INTVAL (XEXP (x, 1));
2497 +
2498 +      if (!mips_valid_base_register_p (base, mode, false))
2499 +       base = copy_to_mode_reg (Pmode, base);
2500 +      addr = mips_add_offset (NULL, base, offset);
2501 +      return mips_force_address (addr, mode);
2502 +    }
2503 +
2504 +  return x;
2505 +}
2506 +
2507 +static int
2508 +riscv_split_integer_cost (HOST_WIDE_INT val)
2509 +{
2510 +  int cost = 0;
2511 +  struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
2512 +  int32_t loval = val, hival = (val - (int32_t)val) >> 32;
2513 +
2514 +  cost += riscv_build_integer(codes, loval);
2515 +  if (loval != hival)
2516 +    cost += riscv_build_integer(codes, hival);
2517 +  return cost + 2;
2518 +}
2519 +
2520 +/* Try to split a 64b integer into 32b parts, then reassemble. */
2521 +
2522 +static rtx
2523 +riscv_split_integer (HOST_WIDE_INT val, enum machine_mode mode)
2524 +{
2525 +  int32_t loval = val, hival = (val - (int32_t)val) >> 32;
2526 +  rtx hi = gen_reg_rtx (mode), lo = gen_reg_rtx (mode);
2527 +
2528 +  mips_move_integer (hi, hi, hival);
2529 +  mips_move_integer (lo, lo, loval);
2530 +
2531 +  hi = gen_rtx_fmt_ee (ASHIFT, mode, hi, GEN_INT (32));
2532 +  hi = force_reg (mode, hi);
2533 +
2534 +  return gen_rtx_fmt_ee (PLUS, mode, hi, lo);
2535 +}
2536 +
2537 +/* Load VALUE into DEST.  TEMP is as for mips_force_temporary.  */
2538 +
2539 +void
2540 +mips_move_integer (rtx temp, rtx dest, HOST_WIDE_INT value)
2541 +{
2542 +  struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
2543 +  enum machine_mode mode;
2544 +  unsigned int i, num_ops;
2545 +  rtx x;
2546 +
2547 +  mode = GET_MODE (dest);
2548 +  num_ops = riscv_build_integer (codes, value);
2549 +
2550 +  if (can_create_pseudo_p () && num_ops >= riscv_split_integer_cost (value))
2551 +    x = riscv_split_integer (value, mode);
2552 +  else
2553 +    {
2554 +      /* Apply each binary operation to X. */
2555 +      x = GEN_INT (codes[0].value);
2556 +
2557 +      for (i = 1; i < num_ops; i++)
2558 +        {
2559 +          if (!can_create_pseudo_p ())
2560 +            {
2561 +              emit_insn (gen_rtx_SET (VOIDmode, temp, x));
2562 +              x = temp;
2563 +            }
2564 +          else
2565 +            x = force_reg (mode == HImode ? SImode : mode, x);
2566 +
2567 +          x = gen_rtx_fmt_ee (codes[i].code, mode, x, GEN_INT (codes[i].value));
2568 +        }
2569 +    }
2570 +
2571 +  emit_insn (gen_rtx_SET (VOIDmode, dest, x));
2572 +}
2573 +
2574 +/* Subroutine of mips_legitimize_move.  Move constant SRC into register
2575 +   DEST given that SRC satisfies immediate_operand but doesn't satisfy
2576 +   move_operand.  */
2577 +
2578 +static void
2579 +mips_legitimize_const_move (enum machine_mode mode, rtx dest, rtx src)
2580 +{
2581 +  rtx base, offset;
2582 +
2583 +  /* Split moves of big integers into smaller pieces.  */
2584 +  if (splittable_const_int_operand (src, mode))
2585 +    {
2586 +      mips_move_integer (dest, dest, INTVAL (src));
2587 +      return;
2588 +    }
2589 +
2590 +  /* Split moves of symbolic constants into high/low pairs.  */
2591 +  if (mips_split_symbol (dest, src, MAX_MACHINE_MODE, &src))
2592 +    {
2593 +      emit_insn (gen_rtx_SET (VOIDmode, dest, src));
2594 +      return;
2595 +    }
2596 +
2597 +  /* Generate the appropriate access sequences for TLS symbols.  */
2598 +  if (mips_tls_symbol_p (src))
2599 +    {
2600 +      mips_emit_move (dest, mips_legitimize_tls_address (src));
2601 +      return;
2602 +    }
2603 +
2604 +  /* If we have (const (plus symbol offset)), and that expression cannot
2605 +     be forced into memory, load the symbol first and add in the offset.
2606 +     In non-MIPS16 mode, prefer to do this even if the constant _can_ be
2607 +     forced into memory, as it usually produces better code.  */
2608 +  split_const (src, &base, &offset);
2609 +  if (offset != const0_rtx
2610 +      && (targetm.cannot_force_const_mem (src)
2611 +         || can_create_pseudo_p ()))
2612 +    {
2613 +      base = mips_force_temporary (dest, base);
2614 +      mips_emit_move (dest, mips_add_offset (NULL, base, INTVAL (offset)));
2615 +      return;
2616 +    }
2617 +
2618 +  src = force_const_mem (mode, src);
2619 +
2620 +  /* When using explicit relocs, constant pool references are sometimes
2621 +     not legitimate addresses.  */
2622 +  mips_split_symbol (dest, XEXP (src, 0), mode, &XEXP (src, 0));
2623 +  mips_emit_move (dest, src);
2624 +}
2625 +
2626 +/* If (set DEST SRC) is not a valid move instruction, emit an equivalent
2627 +   sequence that is valid.  */
2628 +
2629 +bool
2630 +mips_legitimize_move (enum machine_mode mode, rtx dest, rtx src)
2631 +{
2632 +  if (!register_operand (dest, mode) && !reg_or_0_operand (src, mode))
2633 +    {
2634 +      mips_emit_move (dest, force_reg (mode, src));
2635 +      return true;
2636 +    }
2637 +
2638 +  /* We need to deal with constants that would be legitimate
2639 +     immediate_operands but aren't legitimate move_operands.  */
2640 +  if (CONSTANT_P (src) && !move_operand (src, mode))
2641 +    {
2642 +      mips_legitimize_const_move (mode, dest, src);
2643 +      set_unique_reg_note (get_last_insn (), REG_EQUAL, copy_rtx (src));
2644 +      return true;
2645 +    }
2646 +  return false;
2647 +}
2648 +
2649 +bool
2650 +mips_legitimize_vector_move (enum machine_mode mode, rtx dest, rtx src)
2651 +{
2652 +  bool dest_mem, dest_mem_reg;
2653 +  bool src_mem, src_mem_reg;
2654 +
2655 +  dest_mem = (GET_CODE(dest) == MEM);
2656 +  dest_mem_reg = dest_mem && GET_CODE(XEXP(dest, 0)) == REG;
2657 +
2658 +  src_mem = (GET_CODE(src) == MEM);
2659 +  src_mem_reg = src_mem && GET_CODE(XEXP(src, 0)) == REG;
2660 +
2661 +  if (dest_mem && !dest_mem_reg)
2662 +  {
2663 +    rtx add, scratch, base, move;
2664 +    HOST_WIDE_INT offset;
2665 +
2666 +    mips_split_plus(XEXP(dest,0), &base, &offset);
2667 +
2668 +    scratch = gen_reg_rtx(Pmode);
2669 +    add = gen_add3_insn(scratch, base, GEN_INT(offset));
2670 +    emit_insn(add);
2671 +
2672 +    switch (mode)
2673 +    {
2674 +      case MIPS_RISCV_VECTOR_MODE_NAME(DI):
2675 +        move = gen_movv32di(gen_rtx_MEM(mode, scratch), src);
2676 +        break;
2677 +      case MIPS_RISCV_VECTOR_MODE_NAME(SI):
2678 +        move = gen_movv32si(gen_rtx_MEM(mode, scratch), src);
2679 +        break;
2680 +      case MIPS_RISCV_VECTOR_MODE_NAME(HI):
2681 +        move = gen_movv32hi(gen_rtx_MEM(mode, scratch), src);
2682 +        break;
2683 +      case MIPS_RISCV_VECTOR_MODE_NAME(QI):
2684 +        move = gen_movv32qi(gen_rtx_MEM(mode, scratch), src);
2685 +        break;
2686 +      case MIPS_RISCV_VECTOR_MODE_NAME(DF):
2687 +        move = gen_movv32df(gen_rtx_MEM(mode, scratch), src);
2688 +        break;
2689 +      case MIPS_RISCV_VECTOR_MODE_NAME(SF):
2690 +        move = gen_movv32sf(gen_rtx_MEM(mode, scratch), src);
2691 +        break;
2692 +      default:
2693 +        gcc_unreachable();
2694 +    }
2695 +
2696 +    emit_insn(move);
2697 +
2698 +    return true;
2699 +  }
2700 +
2701 +  if (src_mem && !src_mem_reg)
2702 +  {
2703 +    rtx add, scratch, base, move;
2704 +    HOST_WIDE_INT offset;
2705 +
2706 +    mips_split_plus(XEXP(src,0), &base, &offset);
2707 +
2708 +    scratch = gen_reg_rtx(Pmode);
2709 +    add = gen_add3_insn(scratch, base, GEN_INT(offset));
2710 +    emit_insn(add);
2711 +
2712 +    switch (mode)
2713 +    {
2714 +      case MIPS_RISCV_VECTOR_MODE_NAME(DI):
2715 +        move = gen_movv32di(dest, gen_rtx_MEM(mode, scratch));
2716 +        break;
2717 +      case MIPS_RISCV_VECTOR_MODE_NAME(SI):
2718 +        move = gen_movv32si(dest, gen_rtx_MEM(mode, scratch));
2719 +        break;
2720 +      case MIPS_RISCV_VECTOR_MODE_NAME(HI):
2721 +        move = gen_movv32hi(dest, gen_rtx_MEM(mode, scratch));
2722 +        break;
2723 +      case MIPS_RISCV_VECTOR_MODE_NAME(QI):
2724 +        move = gen_movv32qi(dest, gen_rtx_MEM(mode, scratch));
2725 +        break;
2726 +      case MIPS_RISCV_VECTOR_MODE_NAME(DF):
2727 +        move = gen_movv32df(dest, gen_rtx_MEM(mode, scratch));
2728 +        break;
2729 +      case MIPS_RISCV_VECTOR_MODE_NAME(SF):
2730 +        move = gen_movv32sf(dest, gen_rtx_MEM(mode, scratch));
2731 +        break;
2732 +      default:
2733 +        gcc_unreachable();
2734 +    }
2735 +
2736 +    emit_insn(move);
2737 +
2738 +    return true;
2739 +  }
2740 +
2741 +  return false;
2742 +}
2743 +
2744 +/* The cost of loading values from the constant pool.  It should be
2745 +   larger than the cost of any constant we want to synthesize inline.  */
2746 +#define CONSTANT_POOL_COST COSTS_N_INSNS (8)
2747 +
2748 +/* Return true if there is a non-MIPS16 instruction that implements CODE
2749 +   and if that instruction accepts X as an immediate operand.  */
2750 +
2751 +static int
2752 +mips_immediate_operand_p (int code, HOST_WIDE_INT x)
2753 +{
2754 +  switch (code)
2755 +    {
2756 +    case ASHIFT:
2757 +    case ASHIFTRT:
2758 +    case LSHIFTRT:
2759 +      /* All shift counts are truncated to a valid constant.  */
2760 +      return true;
2761 +
2762 +    case AND:
2763 +    case IOR:
2764 +    case XOR:
2765 +    case PLUS:
2766 +    case LT:
2767 +    case LTU:
2768 +      /* These instructions take 12-bit signed immediates.  */
2769 +      return SMALL_OPERAND (x);
2770 +
2771 +    case LE:
2772 +      /* We add 1 to the immediate and use SLT.  */
2773 +      return SMALL_OPERAND (x + 1);
2774 +
2775 +    case LEU:
2776 +      /* Likewise SLTU, but reject the always-true case.  */
2777 +      return SMALL_OPERAND (x + 1) && x + 1 != 0;
2778 +
2779 +    case GE:
2780 +    case GEU:
2781 +      /* We can emulate an immediate of 1 by using GT/GTU against x0. */
2782 +      return x == 1;
2783 +
2784 +    default:
2785 +      /* By default assume that x0 can be used for 0.  */
2786 +      return x == 0;
2787 +    }
2788 +}
2789 +
2790 +/* Return the cost of binary operation X, given that the instruction
2791 +   sequence for a word-sized or smaller operation has cost SINGLE_COST
2792 +   and that the sequence of a double-word operation has cost DOUBLE_COST.
2793 +   If SPEED is true, optimize for speed otherwise optimize for size.  */
2794 +
2795 +static int
2796 +mips_binary_cost (rtx x, int single_cost, int double_cost, bool speed)
2797 +{
2798 +  if (GET_MODE_SIZE (GET_MODE (x)) == UNITS_PER_WORD * 2)
2799 +    single_cost = double_cost;
2800 +
2801 +  return (single_cost
2802 +         + rtx_cost (XEXP (x, 0), SET, speed)
2803 +         + rtx_cost (XEXP (x, 1), GET_CODE (x), speed));
2804 +}
2805 +
2806 +/* Return the cost of floating-point multiplications of mode MODE.  */
2807 +
2808 +static int
2809 +mips_fp_mult_cost (enum machine_mode mode)
2810 +{
2811 +  return mode == DFmode ? mips_cost->fp_mult_df : mips_cost->fp_mult_sf;
2812 +}
2813 +
2814 +/* Return the cost of floating-point divisions of mode MODE.  */
2815 +
2816 +static int
2817 +mips_fp_div_cost (enum machine_mode mode)
2818 +{
2819 +  return mode == DFmode ? mips_cost->fp_div_df : mips_cost->fp_div_sf;
2820 +}
2821 +
2822 +/* Return the cost of sign-extending OP to mode MODE, not including the
2823 +   cost of OP itself.  */
2824 +
2825 +static int
2826 +mips_sign_extend_cost (enum machine_mode mode, rtx op)
2827 +{
2828 +  if (MEM_P (op))
2829 +    /* Extended loads are as cheap as unextended ones.  */
2830 +    return 0;
2831 +
2832 +  if (TARGET_64BIT && mode == DImode && GET_MODE (op) == SImode)
2833 +    /* A sign extension from SImode to DImode in 64-bit mode is free.  */
2834 +    return 0;
2835 +
2836 +  /* We need to use a shift left and a shift right.  */
2837 +  return COSTS_N_INSNS (2);
2838 +}
2839 +
2840 +/* Return the cost of zero-extending OP to mode MODE, not including the
2841 +   cost of OP itself.  */
2842 +
2843 +static int
2844 +mips_zero_extend_cost (enum machine_mode mode, rtx op)
2845 +{
2846 +  if (MEM_P (op))
2847 +    /* Extended loads are as cheap as unextended ones.  */
2848 +    return 0;
2849 +
2850 +  if ((TARGET_64BIT && mode == DImode && GET_MODE (op) == SImode) ||
2851 +      ((mode == DImode || mode == SImode) && GET_MODE (op) == HImode))
2852 +    /* We need a shift left by 32 bits and a shift right by 32 bits.  */
2853 +    return COSTS_N_INSNS (2);
2854 +
2855 +  /* We can use ANDI.  */
2856 +  return COSTS_N_INSNS (1);
2857 +}
2858 +
2859 +/* Implement TARGET_RTX_COSTS.  */
2860 +
2861 +static bool
2862 +mips_rtx_costs (rtx x, int code, int outer_code, int *total, bool speed)
2863 +{
2864 +  enum machine_mode mode = GET_MODE (x);
2865 +  bool float_mode_p = FLOAT_MODE_P (mode);
2866 +  int cost;
2867 +  rtx addr;
2868 +
2869 +  /* The cost of a COMPARE is hard to define for MIPS.  COMPAREs don't
2870 +     appear in the instruction stream, and the cost of a comparison is
2871 +     really the cost of the branch or scc condition.  At the time of
2872 +     writing, GCC only uses an explicit outer COMPARE code when optabs
2873 +     is testing whether a constant is expensive enough to force into a
2874 +     register.  We want optabs to pass such constants through the MIPS
2875 +     expanders instead, so make all constants very cheap here.  */
2876 +  if (outer_code == COMPARE)
2877 +    {
2878 +      gcc_assert (CONSTANT_P (x));
2879 +      *total = 0;
2880 +      return true;
2881 +    }
2882 +
2883 +  switch (code)
2884 +    {
2885 +    case CONST_INT:
2886 +      /* Treat *clear_upper32-style ANDs as having zero cost in the
2887 +        second operand.  The cost is entirely in the first operand.
2888 +
2889 +        ??? This is needed because we would otherwise try to CSE
2890 +        the constant operand.  Although that's the right thing for
2891 +        instructions that continue to be a register operation throughout
2892 +        compilation, it is disastrous for instructions that could
2893 +        later be converted into a memory operation.  */
2894 +      if (TARGET_64BIT
2895 +         && outer_code == AND
2896 +         && UINTVAL (x) == 0xffffffff)
2897 +       {
2898 +         *total = 0;
2899 +         return true;
2900 +       }
2901 +
2902 +      /* When not optimizing for size, we care more about the cost
2903 +         of hot code, and hot code is often in a loop.  If a constant
2904 +         operand needs to be forced into a register, we will often be
2905 +         able to hoist the constant load out of the loop, so the load
2906 +         should not contribute to the cost.  */
2907 +      if (speed || mips_immediate_operand_p (outer_code, INTVAL (x)))
2908 +        {
2909 +          *total = 0;
2910 +          return true;
2911 +        }
2912 +      /* Fall through.  */
2913 +
2914 +    case CONST:
2915 +    case SYMBOL_REF:
2916 +    case LABEL_REF:
2917 +    case CONST_DOUBLE:
2918 +      cost = mips_const_insns (x);
2919 +      if (cost > 0)
2920 +       {
2921 +         /* If the constant is likely to be stored in a GPR, SETs of
2922 +            single-insn constants are as cheap as register sets; we
2923 +            never want to CSE them.
2924 +
2925 +            Don't reduce the cost of storing a floating-point zero in
2926 +            FPRs.  If we have a zero in an FPR for other reasons, we
2927 +            can get better cfg-cleanup and delayed-branch results by
2928 +            using it consistently, rather than using $0 sometimes and
2929 +            an FPR at other times.  Also, moves between floating-point
2930 +            registers are sometimes cheaper than (D)MTC1 $0.  */
2931 +         if (cost == 1
2932 +             && outer_code == SET
2933 +             && !(float_mode_p && TARGET_HARD_FLOAT))
2934 +           cost = 0;
2935 +         /* When non-MIPS16 code loads a constant N>1 times, we rarely
2936 +            want to CSE the constant itself.  It is usually better to
2937 +            have N copies of the last operation in the sequence and one
2938 +            shared copy of the other operations.  (Note that this is
2939 +            not true for MIPS16 code, where the final operation in the
2940 +            sequence is often an extended instruction.)
2941 +
2942 +            Also, if we have a CONST_INT, we don't know whether it is
2943 +            for a word or doubleword operation, so we cannot rely on
2944 +            the result of riscv_build_integer.  */
2945 +         else if (outer_code == SET || mode == VOIDmode)
2946 +           cost = 1;
2947 +         *total = COSTS_N_INSNS (cost);
2948 +         return true;
2949 +       }
2950 +      /* The value will need to be fetched from the constant pool.  */
2951 +      *total = CONSTANT_POOL_COST;
2952 +      return true;
2953 +
2954 +    case MEM:
2955 +      /* If the address is legitimate, return the number of
2956 +        instructions it needs.  */
2957 +      addr = XEXP (x, 0);
2958 +      cost = mips_address_insns (addr, mode, true);
2959 +      if (cost > 0)
2960 +       {
2961 +         *total = COSTS_N_INSNS (cost + (speed ? mips_cost->memory_latency : 1));
2962 +         return true;
2963 +       }
2964 +      /* Otherwise use the default handling.  */
2965 +      return false;
2966 +
2967 +    case FFS:
2968 +      *total = COSTS_N_INSNS (6);
2969 +      return false;
2970 +
2971 +    case NOT:
2972 +      *total = COSTS_N_INSNS (GET_MODE_SIZE (mode) > UNITS_PER_WORD ? 2 : 1);
2973 +      return false;
2974 +
2975 +    case AND:
2976 +      /* Check for a *clear_upper32 pattern and treat it like a zero
2977 +        extension.  See the pattern's comment for details.  */
2978 +      if (TARGET_64BIT
2979 +         && mode == DImode
2980 +         && CONST_INT_P (XEXP (x, 1))
2981 +         && UINTVAL (XEXP (x, 1)) == 0xffffffff)
2982 +       {
2983 +         *total = (mips_zero_extend_cost (mode, XEXP (x, 0))
2984 +                   + rtx_cost (XEXP (x, 0), SET, speed));
2985 +         return true;
2986 +       }
2987 +      /* Fall through.  */
2988 +
2989 +    case IOR:
2990 +    case XOR:
2991 +      /* Double-word operations use two single-word operations.  */
2992 +      *total = mips_binary_cost (x, COSTS_N_INSNS (1), COSTS_N_INSNS (2),
2993 +                                speed);
2994 +      return true;
2995 +
2996 +    case ASHIFT:
2997 +    case ASHIFTRT:
2998 +    case LSHIFTRT:
2999 +    case ROTATE:
3000 +    case ROTATERT:
3001 +      if (CONSTANT_P (XEXP (x, 1)))
3002 +       *total = mips_binary_cost (x, COSTS_N_INSNS (1), COSTS_N_INSNS (4),
3003 +                                  speed);
3004 +      else
3005 +       *total = mips_binary_cost (x, COSTS_N_INSNS (1), COSTS_N_INSNS (12),
3006 +                                  speed);
3007 +      return true;
3008 +
3009 +    case ABS:
3010 +      if (float_mode_p)
3011 +        *total = mips_cost->fp_add;
3012 +      else
3013 +        *total = COSTS_N_INSNS (4);
3014 +      return false;
3015 +
3016 +    case LO_SUM:
3017 +      /* Low-part immediates need an extended MIPS16 instruction.  */
3018 +      *total = (COSTS_N_INSNS (1)
3019 +               + rtx_cost (XEXP (x, 0), SET, speed));
3020 +      return true;
3021 +
3022 +    case LT:
3023 +    case LTU:
3024 +    case LE:
3025 +    case LEU:
3026 +    case GT:
3027 +    case GTU:
3028 +    case GE:
3029 +    case GEU:
3030 +    case EQ:
3031 +    case NE:
3032 +    case UNORDERED:
3033 +    case LTGT:
3034 +      /* Branch comparisons have VOIDmode, so use the first operand's
3035 +        mode instead.  */
3036 +      mode = GET_MODE (XEXP (x, 0));
3037 +      if (FLOAT_MODE_P (mode))
3038 +       {
3039 +         *total = mips_cost->fp_add;
3040 +         return false;
3041 +       }
3042 +      *total = mips_binary_cost (x, COSTS_N_INSNS (1), COSTS_N_INSNS (4),
3043 +                                speed);
3044 +      return true;
3045 +
3046 +    case MINUS:
3047 +      if (float_mode_p
3048 +         && !HONOR_NANS (mode)
3049 +         && !HONOR_SIGNED_ZEROS (mode))
3050 +       {
3051 +         /* See if we can use NMADD or NMSUB.  See mips.md for the
3052 +            associated patterns.  */
3053 +         rtx op0 = XEXP (x, 0);
3054 +         rtx op1 = XEXP (x, 1);
3055 +         if (GET_CODE (op0) == MULT && GET_CODE (XEXP (op0, 0)) == NEG)
3056 +           {
3057 +             *total = (mips_fp_mult_cost (mode)
3058 +                       + rtx_cost (XEXP (XEXP (op0, 0), 0), SET, speed)
3059 +                       + rtx_cost (XEXP (op0, 1), SET, speed)
3060 +                       + rtx_cost (op1, SET, speed));
3061 +             return true;
3062 +           }
3063 +         if (GET_CODE (op1) == MULT)
3064 +           {
3065 +             *total = (mips_fp_mult_cost (mode)
3066 +                       + rtx_cost (op0, SET, speed)
3067 +                       + rtx_cost (XEXP (op1, 0), SET, speed)
3068 +                       + rtx_cost (XEXP (op1, 1), SET, speed));
3069 +             return true;
3070 +           }
3071 +       }
3072 +      /* Fall through.  */
3073 +
3074 +    case PLUS:
3075 +      if (float_mode_p)
3076 +       {
3077 +         /* If this is part of a MADD or MSUB, treat the PLUS as
3078 +            being free.  */
3079 +         if (GET_CODE (XEXP (x, 0)) == MULT)
3080 +           *total = 0;
3081 +         else
3082 +           *total = mips_cost->fp_add;
3083 +         return false;
3084 +       }
3085 +
3086 +      /* Double-word operations require three single-word operations and
3087 +        an SLTU.  The MIPS16 version then needs to move the result of
3088 +        the SLTU from $24 to a MIPS16 register.  */
3089 +      *total = mips_binary_cost (x, COSTS_N_INSNS (1),
3090 +                                COSTS_N_INSNS (4),
3091 +                                speed);
3092 +      return true;
3093 +
3094 +    case NEG:
3095 +      if (float_mode_p
3096 +         && !HONOR_NANS (mode)
3097 +         && HONOR_SIGNED_ZEROS (mode))
3098 +       {
3099 +         /* See if we can use NMADD or NMSUB.  See mips.md for the
3100 +            associated patterns.  */
3101 +         rtx op = XEXP (x, 0);
3102 +         if ((GET_CODE (op) == PLUS || GET_CODE (op) == MINUS)
3103 +             && GET_CODE (XEXP (op, 0)) == MULT)
3104 +           {
3105 +             *total = (mips_fp_mult_cost (mode)
3106 +                       + rtx_cost (XEXP (XEXP (op, 0), 0), SET, speed)
3107 +                       + rtx_cost (XEXP (XEXP (op, 0), 1), SET, speed)
3108 +                       + rtx_cost (XEXP (op, 1), SET, speed));
3109 +             return true;
3110 +           }
3111 +       }
3112 +
3113 +      if (float_mode_p)
3114 +       *total = mips_cost->fp_add;
3115 +      else
3116 +       *total = COSTS_N_INSNS (GET_MODE_SIZE (mode) > UNITS_PER_WORD ? 4 : 1);
3117 +      return false;
3118 +
3119 +    case MULT:
3120 +      if (float_mode_p)
3121 +       *total = mips_fp_mult_cost (mode);
3122 +      else if (mode == DImode && !TARGET_64BIT)
3123 +       /* We use a MUL and a MULH[[S]U]. */
3124 +       *total = mips_cost->int_mult_si * 2;
3125 +      else if (!speed)
3126 +       *total = 1;
3127 +      else if (mode == DImode)
3128 +       *total = mips_cost->int_mult_di;
3129 +      else
3130 +       *total = mips_cost->int_mult_si;
3131 +      return false;
3132 +
3133 +    case DIV:
3134 +      /* Check for a reciprocal.  */
3135 +      if (float_mode_p
3136 +         && flag_unsafe_math_optimizations
3137 +         && XEXP (x, 0) == CONST1_RTX (mode))
3138 +       {
3139 +         if (outer_code == SQRT || GET_CODE (XEXP (x, 1)) == SQRT)
3140 +           /* An rsqrt<mode>a or rsqrt<mode>b pattern.  Count the
3141 +              division as being free.  */
3142 +           *total = rtx_cost (XEXP (x, 1), SET, speed);
3143 +         else
3144 +           *total = (mips_fp_div_cost (mode)
3145 +                     + rtx_cost (XEXP (x, 1), SET, speed));
3146 +         return true;
3147 +       }
3148 +      /* Fall through.  */
3149 +
3150 +    case SQRT:
3151 +    case MOD:
3152 +      if (float_mode_p)
3153 +       {
3154 +         *total = mips_fp_div_cost (mode);
3155 +         return false;
3156 +       }
3157 +      /* Fall through.  */
3158 +
3159 +    case UDIV:
3160 +    case UMOD:
3161 +      if (!speed)
3162 +       *total = 1;
3163 +      else if (mode == DImode)
3164 +        *total = mips_cost->int_div_di;
3165 +      else
3166 +       *total = mips_cost->int_div_si;
3167 +      return false;
3168 +
3169 +    case SIGN_EXTEND:
3170 +      *total = mips_sign_extend_cost (mode, XEXP (x, 0));
3171 +      return false;
3172 +
3173 +    case ZERO_EXTEND:
3174 +      *total = mips_zero_extend_cost (mode, XEXP (x, 0));
3175 +      return false;
3176 +
3177 +    case FLOAT:
3178 +    case UNSIGNED_FLOAT:
3179 +    case FIX:
3180 +    case FLOAT_EXTEND:
3181 +    case FLOAT_TRUNCATE:
3182 +      *total = mips_cost->fp_add;
3183 +      return false;
3184 +
3185 +    default:
3186 +      return false;
3187 +    }
3188 +}
3189 +
3190 +/* Implement TARGET_ADDRESS_COST.  */
3191 +
3192 +static int
3193 +mips_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
3194 +{
3195 +  return mips_address_insns (addr, SImode, false);
3196 +}
3197 +
3198 +/* Return one word of double-word value OP, taking into account the fixed
3199 +   endianness of certain registers.  HIGH_P is true to select the high part,
3200 +   false to select the low part.  */
3201 +
3202 +rtx
3203 +mips_subword (rtx op, bool high_p)
3204 +{
3205 +  unsigned int byte, offset;
3206 +  enum machine_mode mode;
3207 +
3208 +  mode = GET_MODE (op);
3209 +  if (mode == VOIDmode)
3210 +    mode = TARGET_64BIT ? TImode : DImode;
3211 +
3212 +  if (TARGET_BIG_ENDIAN ? !high_p : high_p)
3213 +    byte = UNITS_PER_WORD;
3214 +  else
3215 +    byte = 0;
3216 +
3217 +  if (FP_REG_RTX_P (op))
3218 +    {
3219 +      /* Paired FPRs are always ordered little-endian.  */
3220 +      offset = (UNITS_PER_WORD < UNITS_PER_HWFPVALUE ? high_p : byte != 0);
3221 +      return gen_rtx_REG (word_mode, REGNO (op) + offset);
3222 +    }
3223 +
3224 +  if (MEM_P (op))
3225 +    return adjust_address (op, word_mode, byte);
3226 +
3227 +  return simplify_gen_subreg (word_mode, op, mode, byte);
3228 +}
3229 +
3230 +/* Return true if a 64-bit move from SRC to DEST should be split into two.  */
3231 +
3232 +bool
3233 +mips_split_64bit_move_p (rtx dest, rtx src)
3234 +{
3235 +  /* All 64b moves are legal in 64b mode.  All 64b FPR <-> FPR and
3236 +     FPR <-> MEM moves are legal in 32b mode, too.  Although
3237 +     FPR <-> GPR moves are not available in general in 32b mode,
3238 +     we can at least load 0 into an FPR with fcvt.d.w fpr, x0. */
3239 +  return !(TARGET_64BIT
3240 +          || (FP_REG_RTX_P (src) && FP_REG_RTX_P (dest))
3241 +          || (FP_REG_RTX_P (dest) && MEM_P (src))
3242 +          || (FP_REG_RTX_P (src) && MEM_P (dest))
3243 +          || (FP_REG_RTX_P(dest) && src == CONST0_RTX(GET_MODE(src))));
3244 +}
3245 +
3246 +/* Split a doubleword move from SRC to DEST.  On 32-bit targets,
3247 +   this function handles 64-bit moves for which mips_split_64bit_move_p
3248 +   holds.  For 64-bit targets, this function handles 128-bit moves.  */
3249 +
3250 +void
3251 +mips_split_doubleword_move (rtx dest, rtx src)
3252 +{
3253 +  rtx low_dest;
3254 +
3255 +   /* The operation can be split into two normal moves.  Decide in
3256 +      which order to do them.  */
3257 +   low_dest = mips_subword (dest, false);
3258 +   if (REG_P (low_dest) && reg_overlap_mentioned_p (low_dest, src))
3259 +     {
3260 +       mips_emit_move (mips_subword (dest, true), mips_subword (src, true));
3261 +       mips_emit_move (low_dest, mips_subword (src, false));
3262 +     }
3263 +   else
3264 +     {
3265 +       mips_emit_move (low_dest, mips_subword (src, false));
3266 +       mips_emit_move (mips_subword (dest, true), mips_subword (src, true));
3267 +     }
3268 +}
3269 +\f
3270 +/* Return the appropriate instructions to move SRC into DEST.  Assume
3271 +   that SRC is operand 1 and DEST is operand 0.  */
3272 +
3273 +const char *
3274 +mips_output_move (rtx dest, rtx src)
3275 +{
3276 +  enum rtx_code dest_code, src_code;
3277 +  enum machine_mode mode;
3278 +  enum mips_symbol_type symbol_type;
3279 +  bool dbl_p;
3280 +
3281 +  dest_code = GET_CODE (dest);
3282 +  src_code = GET_CODE (src);
3283 +  mode = GET_MODE (dest);
3284 +  dbl_p = (GET_MODE_SIZE (mode) == 8);
3285 +
3286 +  if (dbl_p && mips_split_64bit_move_p (dest, src))
3287 +    return "#";
3288 +
3289 +  if ((src_code == REG && GP_REG_P (REGNO (src)))
3290 +      || (src == CONST0_RTX (mode)))
3291 +    {
3292 +      if (dest_code == REG)
3293 +       {
3294 +         if (GP_REG_P (REGNO (dest)))
3295 +           return "move\t%0,%z1";
3296 +
3297 +         if (FP_REG_P (REGNO (dest)))
3298 +           {
3299 +             if (!dbl_p)
3300 +               return "mxtf.s\t%0,%z1";
3301 +             if (TARGET_64BIT)
3302 +               return "mxtf.d\t%0,%z1";
3303 +             /* in RV32, we can emulate mxtf.d %0, x0 using fcvt.d.w */
3304 +             gcc_assert (src == CONST0_RTX (mode));
3305 +             return "fcvt.d.w\t%0,x0";
3306 +           }
3307 +       }
3308 +      if (dest_code == MEM)
3309 +       switch (GET_MODE_SIZE (mode))
3310 +         {
3311 +         case 1: return "sb\t%z1,%0";
3312 +         case 2: return "sh\t%z1,%0";
3313 +         case 4: return "sw\t%z1,%0";
3314 +         case 8: return "sd\t%z1,%0";
3315 +         }
3316 +    }
3317 +  if (dest_code == REG && GP_REG_P (REGNO (dest)))
3318 +    {
3319 +      if (src_code == REG)
3320 +       {
3321 +         if (FP_REG_P (REGNO (src)))
3322 +           return dbl_p ? "mftx.d\t%0,%1" : "mftx.s\t%0,%1";
3323 +       }
3324 +
3325 +      if (src_code == MEM)
3326 +       switch (GET_MODE_SIZE (mode))
3327 +         {
3328 +         case 1: return "lbu\t%0,%1";
3329 +         case 2: return "lhu\t%0,%1";
3330 +         case 4: return "lw\t%0,%1";
3331 +         case 8: return "ld\t%0,%1";
3332 +         }
3333 +
3334 +      if (src_code == CONST_INT)
3335 +       return "li\t%0,%1\t\t\t# %X1";
3336 +
3337 +      if (src_code == HIGH)
3338 +       return "lui\t%0,%h1";
3339 +
3340 +      if (mips_symbolic_constant_p (src, &symbol_type)
3341 +         && mips_lo_relocs[symbol_type] != 0)
3342 +       {
3343 +         /* A signed 16-bit constant formed by applying a relocation
3344 +            operator to a symbolic address.  */
3345 +         gcc_assert (!mips_split_p[symbol_type]);
3346 +         return "li\t%0,%R1";
3347 +       }
3348 +
3349 +      if (symbolic_operand (src, VOIDmode))
3350 +       {
3351 +         gcc_assert (flag_pic);
3352 +         return "la\t%0,%1";
3353 +       }
3354 +    }
3355 +  if (src_code == REG && FP_REG_P (REGNO (src)))
3356 +    {
3357 +      if (dest_code == REG && FP_REG_P (REGNO (dest)))
3358 +       return dbl_p ? "fsgnj.d\t%0,%1,%1" : "fsgnj.s\t%0,%1,%1";
3359 +
3360 +      if (dest_code == MEM)
3361 +       return dbl_p ? "fsd\t%1,%0" : "fsw\t%1,%0";
3362 +    }
3363 +  if (dest_code == REG && FP_REG_P (REGNO (dest)))
3364 +    {
3365 +      if (src_code == MEM)
3366 +       return dbl_p ? "fld\t%0,%1" : "flw\t%0,%1";
3367 +    }
3368 +  gcc_unreachable ();
3369 +}
3370 +\f
3371 +/* Return true if CMP1 is a suitable second operand for integer ordering
3372 +   test CODE.  See also the *sCC patterns in mips.md.  */
3373 +
3374 +static bool
3375 +mips_int_order_operand_ok_p (enum rtx_code code, rtx cmp1)