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