gcc/config/rs6000/darwin.md

   1 /* Machine description patterns for PowerPC running Darwin (Mac OS X).
   2    Copyright (C) 2004-2014 Free Software Foundation, Inc.
   3    Contributed by Apple Computer Inc.
   4
   5 This file is part of GCC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 ;; along with GCC; see the file COPYING3.  If not see
  19 ;; <http://www.gnu.org/licenses/>.  */
  20
  21 (define_insn "adddi3_high"
  22   [(set (match_operand:DI 0 "gpc_reg_operand" "=b")
  23         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "b")
  24                  (high:DI (match_operand 2 "" ""))))]
  25   "TARGET_MACHO && TARGET_64BIT"
  26   "addis %0,%1,ha16(%2)"
  27   [(set_attr "length" "4")])
  28
  29 (define_insn "movdf_low_si"
  30   [(set (match_operand:DF 0 "gpc_reg_operand" "=f,!r")
  31         (mem:DF (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b,b")
  32                            (match_operand 2 "" ""))))]
  33   "TARGET_MACHO && TARGET_HARD_FLOAT && TARGET_FPRS && !TARGET_64BIT"
  34   "*
  35 {
  36   switch (which_alternative)
  37     {
  38       case 0:
  39         return \"lfd %0,lo16(%2)(%1)\";
  40       case 1:
  41         {
  42           if (TARGET_POWERPC64 && TARGET_32BIT)
  43             /* Note, old assemblers didn't support relocation here.  */
  44             return \"ld %0,lo16(%2)(%1)\";
  45           else
  46             {
  47               output_asm_insn (\"la %0,lo16(%2)(%1)\", operands);
  48               output_asm_insn (\"lwz %L0,4(%0)\", operands);
  49               return (\"lwz %0,0(%0)\");
  50             }
  51         }
  52       default:
  53         gcc_unreachable ();
  54     }
  55 }"
  56   [(set_attr "type" "load")
  57    (set_attr "length" "4,12")])
  58
  59
  60 (define_insn "movdf_low_di"
  61   [(set (match_operand:DF 0 "gpc_reg_operand" "=f,!r")
  62         (mem:DF (lo_sum:DI (match_operand:DI 1 "gpc_reg_operand" "b,b")
  63                            (match_operand 2 "" ""))))]
  64   "TARGET_MACHO && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_64BIT"
  65   "*
  66 {
  67   switch (which_alternative)
  68     {
  69       case 0:
  70         return \"lfd %0,lo16(%2)(%1)\";
  71       case 1:
  72         return \"ld %0,lo16(%2)(%1)\";
  73       default:
  74         gcc_unreachable ();
  75     }
  76 }"
  77   [(set_attr "type" "load")
  78    (set_attr "length" "4,4")])
  79
  80 (define_insn "movdf_low_st_si"
  81   [(set (mem:DF (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b")
  82                            (match_operand 2 "" "")))
  83         (match_operand:DF 0 "gpc_reg_operand" "f"))]
  84   "TARGET_MACHO && TARGET_HARD_FLOAT && TARGET_FPRS && ! TARGET_64BIT"
  85   "stfd %0,lo16(%2)(%1)"
  86   [(set_attr "type" "store")
  87    (set_attr "length" "4")])
  88
  89 (define_insn "movdf_low_st_di"
  90   [(set (mem:DF (lo_sum:DI (match_operand:DI 1 "gpc_reg_operand" "b")
  91                            (match_operand 2 "" "")))
  92         (match_operand:DF 0 "gpc_reg_operand" "f"))]
  93   "TARGET_MACHO && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_64BIT"
  94   "stfd %0,lo16(%2)(%1)"
  95   [(set_attr "type" "store")
  96    (set_attr "length" "4")])
  97
  98 (define_insn "movsf_low_si"
  99   [(set (match_operand:SF 0 "gpc_reg_operand" "=f,!r")
 100         (mem:SF (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b,b")
 101                            (match_operand 2 "" ""))))]
 102   "TARGET_MACHO && TARGET_HARD_FLOAT && TARGET_FPRS && ! TARGET_64BIT"
 103   "@
 104    lfs %0,lo16(%2)(%1)
 105    lwz %0,lo16(%2)(%1)"
 106   [(set_attr "type" "load")
 107    (set_attr "length" "4")])
 108
 109 (define_insn "movsf_low_di"
 110   [(set (match_operand:SF 0 "gpc_reg_operand" "=f,!r")
 111         (mem:SF (lo_sum:DI (match_operand:DI 1 "gpc_reg_operand" "b,b")
 112                            (match_operand 2 "" ""))))]
 113   "TARGET_MACHO && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_64BIT"
 114   "@
 115    lfs %0,lo16(%2)(%1)
 116    lwz %0,lo16(%2)(%1)"
 117   [(set_attr "type" "load")
 118    (set_attr "length" "4")])
 119
 120 (define_insn "movsf_low_st_si"
 121   [(set (mem:SF (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b,b")
 122                            (match_operand 2 "" "")))
 123         (match_operand:SF 0 "gpc_reg_operand" "f,!r"))]
 124   "TARGET_MACHO && TARGET_HARD_FLOAT && TARGET_FPRS && ! TARGET_64BIT"
 125   "@
 126    stfs %0,lo16(%2)(%1)
 127    stw %0,lo16(%2)(%1)"
 128   [(set_attr "type" "store")
 129    (set_attr "length" "4")])
 130
 131 (define_insn "movsf_low_st_di"
 132   [(set (mem:SF (lo_sum:DI (match_operand:DI 1 "gpc_reg_operand" "b,b")
 133                            (match_operand 2 "" "")))
 134         (match_operand:SF 0 "gpc_reg_operand" "f,!r"))]
 135   "TARGET_MACHO && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_64BIT"
 136   "@
 137    stfs %0,lo16(%2)(%1)
 138    stw %0,lo16(%2)(%1)"
 139   [(set_attr "type" "store")
 140    (set_attr "length" "4")])
 141
 142 ;; 64-bit MachO load/store support
 143 (define_insn "movdi_low"
 144   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,*!d")
 145         (mem:DI (lo_sum:DI (match_operand:DI 1 "gpc_reg_operand" "b,b")
 146                            (match_operand 2 "" ""))))]
 147   "TARGET_MACHO && TARGET_64BIT"
 148   "@
 149    ld %0,lo16(%2)(%1)
 150    lfd %0,lo16(%2)(%1)"
 151   [(set_attr "type" "load")
 152    (set_attr "length" "4")])
 153
 154 (define_insn "movsi_low_st"
 155   [(set (mem:SI (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b")
 156                            (match_operand 2 "" "")))
 157         (match_operand:SI 0 "gpc_reg_operand" "r"))]
 158   "TARGET_MACHO && ! TARGET_64BIT"
 159   "stw %0,lo16(%2)(%1)"
 160   [(set_attr "type" "store")
 161    (set_attr "length" "4")])
 162
 163 (define_insn "movdi_low_st"
 164   [(set (mem:DI (lo_sum:DI (match_operand:DI 1 "gpc_reg_operand" "b,b")
 165                            (match_operand 2 "" "")))
 166         (match_operand:DI 0 "gpc_reg_operand" "r,*!d"))]
 167   "TARGET_MACHO && TARGET_64BIT"
 168   "@
 169    std %0,lo16(%2)(%1)
 170    stfd %0,lo16(%2)(%1)"
 171   [(set_attr "type" "store")
 172    (set_attr "length" "4")])
 173
 174 ;; Mach-O PIC trickery.
 175 (define_expand "macho_high"
 176   [(set (match_operand 0 "" "")
 177         (high (match_operand 1 "" "")))]
 178   "TARGET_MACHO"
 179 {
 180   if (TARGET_64BIT)
 181     emit_insn (gen_macho_high_di (operands[0], operands[1]));
 182   else
 183     emit_insn (gen_macho_high_si (operands[0], operands[1]));
 184
 185   DONE;
 186 })
 187
 188 (define_insn "macho_high_si"
 189   [(set (match_operand:SI 0 "gpc_reg_operand" "=b*r")
 190         (high:SI (match_operand 1 "" "")))]
 191   "TARGET_MACHO && ! TARGET_64BIT"
 192   "lis %0,ha16(%1)")
 193
 194
 195 (define_insn "macho_high_di"
 196   [(set (match_operand:DI 0 "gpc_reg_operand" "=b*r")
 197         (high:DI (match_operand 1 "" "")))]
 198   "TARGET_MACHO && TARGET_64BIT"
 199   "lis %0,ha16(%1)")
 200
 201 (define_expand "macho_low"
 202   [(set (match_operand 0 "" "")
 203         (lo_sum (match_operand 1 "" "")
 204                    (match_operand 2 "" "")))]
 205    "TARGET_MACHO"
 206 {
 207   if (TARGET_64BIT)
 208     emit_insn (gen_macho_low_di (operands[0], operands[1], operands[2]));
 209   else
 210     emit_insn (gen_macho_low_si (operands[0], operands[1], operands[2]));
 211
 212   DONE;
 213 })
 214
 215 (define_insn "macho_low_si"
 216   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 217         (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b,!*r")
 218                    (match_operand 2 "" "")))]
 219    "TARGET_MACHO && ! TARGET_64BIT"
 220    "@
 221     la %0,lo16(%2)(%1)
 222     addic %0,%1,lo16(%2)")
 223
 224 (define_insn "macho_low_di"
 225   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 226         (lo_sum:DI (match_operand:DI 1 "gpc_reg_operand" "b,!*r")
 227                    (match_operand 2 "" "")))]
 228    "TARGET_MACHO && TARGET_64BIT"
 229    "@
 230     la %0,lo16(%2)(%1)
 231     addic %0,%1,lo16(%2)")
 232
 233 (define_split
 234   [(set (mem:V4SI (plus:DI (match_operand:DI 0 "gpc_reg_operand" "")
 235                          (match_operand:DI 1 "short_cint_operand" "")))
 236         (match_operand:V4SI 2 "register_operand" ""))
 237    (clobber (match_operand:DI 3 "gpc_reg_operand" ""))]
 238   "TARGET_MACHO && TARGET_64BIT"
 239   [(set (match_dup 3) (plus:DI (match_dup 0) (match_dup 1)))
 240    (set (mem:V4SI (match_dup 3))
 241         (match_dup 2))]
 242   "")
 243
 244 (define_expand "load_macho_picbase"
 245   [(set (reg:SI 65)
 246         (unspec [(match_operand 0 "" "")]
 247                    UNSPEC_LD_MPIC))]
 248   "(DEFAULT_ABI == ABI_DARWIN) && flag_pic"
 249 {
 250   if (TARGET_32BIT)
 251     emit_insn (gen_load_macho_picbase_si (operands[0]));
 252   else
 253     emit_insn (gen_load_macho_picbase_di (operands[0]));
 254
 255   DONE;
 256 })
 257
 258 (define_insn "load_macho_picbase_si"
 259   [(set (reg:SI 65)
 260         (unspec:SI [(match_operand:SI 0 "immediate_operand" "s")
 261                     (pc)] UNSPEC_LD_MPIC))]
 262   "(DEFAULT_ABI == ABI_DARWIN) && flag_pic"
 263 {
 264 #if TARGET_MACHO
 265   machopic_should_output_picbase_label (); /* Update for new func.  */
 266 #else
 267   gcc_unreachable ();
 268 #endif
 269   return "bcl 20,31,%0\\n%0:";
 270 }
 271   [(set_attr "type" "branch")
 272    (set_attr "length" "4")])
 273
 274 (define_insn "load_macho_picbase_di"
 275   [(set (reg:DI 65)
 276         (unspec:DI [(match_operand:DI 0 "immediate_operand" "s")
 277                     (pc)] UNSPEC_LD_MPIC))]
 278   "(DEFAULT_ABI == ABI_DARWIN) && flag_pic && TARGET_64BIT"
 279 {
 280 #if TARGET_MACHO
 281   machopic_should_output_picbase_label (); /* Update for new func.  */
 282 #else
 283   gcc_unreachable ();
 284 #endif
 285   return "bcl 20,31,%0\\n%0:";
 286 }
 287   [(set_attr "type" "branch")
 288    (set_attr "length" "4")])
 289
 290 (define_expand "macho_correct_pic"
 291   [(set (match_operand 0 "" "")
 292         (plus (match_operand 1 "" "")
 293                  (unspec [(match_operand 2 "" "")
 294                              (match_operand 3 "" "")]
 295                             UNSPEC_MPIC_CORRECT)))]
 296   "DEFAULT_ABI == ABI_DARWIN"
 297 {
 298   if (TARGET_32BIT)
 299     emit_insn (gen_macho_correct_pic_si (operands[0], operands[1], operands[2],
 300                operands[3]));
 301   else
 302     emit_insn (gen_macho_correct_pic_di (operands[0], operands[1], operands[2],
 303                operands[3]));
 304
 305   DONE;
 306 })
 307
 308 (define_insn "macho_correct_pic_si"
 309   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
 310         (plus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
 311                  (unspec:SI [(match_operand:SI 2 "immediate_operand" "s")
 312                              (match_operand:SI 3 "immediate_operand" "s")]
 313                             UNSPEC_MPIC_CORRECT)))]
 314   "DEFAULT_ABI == ABI_DARWIN"
 315   "addis %0,%1,ha16(%2-%3)\n\taddi %0,%0,lo16(%2-%3)"
 316   [(set_attr "length" "8")])
 317
 318 (define_insn "macho_correct_pic_di"
 319   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
 320         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "r")
 321                  (unspec:DI [(match_operand:DI 2 "immediate_operand" "s")
 322                              (match_operand:DI 3 "immediate_operand" "s")]
 323                             16)))]
 324   "DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT"
 325   "addis %0,%1,ha16(%2-%3)\n\taddi %0,%0,lo16(%2-%3)"
 326   [(set_attr "length" "8")])
 327
 328 (define_insn "*call_indirect_nonlocal_darwin64"
 329   [(call (mem:SI (match_operand:DI 0 "register_operand" "c,*l,c,*l"))
 330          (match_operand 1 "" "g,g,g,g"))
 331    (use (match_operand:SI 2 "immediate_operand" "O,O,n,n"))
 332    (clobber (reg:SI 65))]
 333   "DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT"
 334 {
 335   return "b%T0l";
 336 }
 337   [(set_attr "type" "jmpreg,jmpreg,jmpreg,jmpreg")
 338    (set_attr "length" "4,4,8,8")])
 339
 340 (define_insn "*call_nonlocal_darwin64"
 341   [(call (mem:SI (match_operand:DI 0 "symbol_ref_operand" "s,s"))
 342          (match_operand 1 "" "g,g"))
 343    (use (match_operand:SI 2 "immediate_operand" "O,n"))
 344    (clobber (reg:SI 65))]
 345   "(DEFAULT_ABI == ABI_DARWIN)
 346    && (INTVAL (operands[2]) & CALL_LONG) == 0"
 347 {
 348 #if TARGET_MACHO
 349   return output_call(insn, operands, 0, 2);
 350 #else
 351   gcc_unreachable ();
 352 #endif
 353 }
 354   [(set_attr "type" "branch,branch")
 355    (set_attr "length" "4,8")])
 356
 357 (define_insn "*call_value_indirect_nonlocal_darwin64"
 358   [(set (match_operand 0 "" "")
 359         (call (mem:SI (match_operand:DI 1 "register_operand" "c,*l,c,*l"))
 360               (match_operand 2 "" "g,g,g,g")))
 361    (use (match_operand:SI 3 "immediate_operand" "O,O,n,n"))
 362    (clobber (reg:SI 65))]
 363   "DEFAULT_ABI == ABI_DARWIN"
 364 {
 365   return "b%T1l";
 366 }
 367   [(set_attr "type" "jmpreg,jmpreg,jmpreg,jmpreg")
 368    (set_attr "length" "4,4,8,8")])
 369
 370 (define_insn "*call_value_nonlocal_darwin64"
 371   [(set (match_operand 0 "" "")
 372         (call (mem:SI (match_operand:DI 1 "symbol_ref_operand" "s,s"))
 373               (match_operand 2 "" "g,g")))
 374    (use (match_operand:SI 3 "immediate_operand" "O,n"))
 375    (clobber (reg:SI 65))]
 376   "(DEFAULT_ABI == ABI_DARWIN)
 377    && (INTVAL (operands[3]) & CALL_LONG) == 0"
 378 {
 379 #if TARGET_MACHO
 380   return output_call(insn, operands, 1, 3);
 381 #else
 382   gcc_unreachable ();
 383 #endif
 384 }
 385   [(set_attr "type" "branch,branch")
 386    (set_attr "length" "4,8")])
 387
 388 (define_expand "reload_macho_picbase"
 389   [(set (reg:SI 65)
 390         (unspec [(match_operand 0 "" "")]
 391                    UNSPEC_RELD_MPIC))]
 392   "(DEFAULT_ABI == ABI_DARWIN) && flag_pic"
 393 {
 394   if (TARGET_32BIT)
 395     emit_insn (gen_reload_macho_picbase_si (operands[0]));
 396   else
 397     emit_insn (gen_reload_macho_picbase_di (operands[0]));
 398
 399   DONE;
 400 })
 401
 402 (define_insn "reload_macho_picbase_si"
 403   [(set (reg:SI 65)
 404         (unspec:SI [(match_operand:SI 0 "immediate_operand" "s")
 405                     (pc)] UNSPEC_RELD_MPIC))]
 406   "(DEFAULT_ABI == ABI_DARWIN) && flag_pic"
 407 {
 408 #if TARGET_MACHO
 409   if (machopic_should_output_picbase_label ())
 410     {
 411       static char tmp[64];
 412       const char *cnam = machopic_get_function_picbase ();
 413       snprintf (tmp, 64, "bcl 20,31,%s\\n%s:\\n%%0:", cnam, cnam);
 414       return tmp;
 415     }
 416   else
 417 #else
 418   gcc_unreachable ();
 419 #endif
 420     return "bcl 20,31,%0\\n%0:";
 421 }
 422   [(set_attr "type" "branch")
 423    (set_attr "length" "4")])
 424
 425 (define_insn "reload_macho_picbase_di"
 426   [(set (reg:DI 65)
 427         (unspec:DI [(match_operand:DI 0 "immediate_operand" "s")
 428                     (pc)] UNSPEC_RELD_MPIC))]
 429   "(DEFAULT_ABI == ABI_DARWIN) && flag_pic && TARGET_64BIT"
 430 {
 431 #if TARGET_MACHO
 432   if (machopic_should_output_picbase_label ())
 433     {
 434       static char tmp[64];
 435       const char *cnam = machopic_get_function_picbase ();
 436       snprintf (tmp, 64, "bcl 20,31,%s\\n%s:\\n%%0:", cnam, cnam);
 437       return tmp;
 438     }
 439   else
 440 #else
 441   gcc_unreachable ();
 442 #endif
 443     return "bcl 20,31,%0\\n%0:";
 444 }
 445   [(set_attr "type" "branch")
 446    (set_attr "length" "4")])
 447
 448 ;; We need to restore the PIC register, at the site of nonlocal label.
 449
 450 (define_insn_and_split "nonlocal_goto_receiver"
 451   [(unspec_volatile [(const_int 0)] UNSPECV_NLGR)]
 452   "TARGET_MACHO && flag_pic"
 453   "#"
 454   "&& reload_completed"
 455   [(const_int 0)]
 456 {
 457 #if TARGET_MACHO
 458   if (crtl->uses_pic_offset_table)
 459     {
 460       static unsigned n = 0;
 461       rtx picrtx = gen_rtx_SYMBOL_REF (Pmode, MACHOPIC_FUNCTION_BASE_NAME);
 462       rtx picreg = gen_rtx_REG (Pmode, RS6000_PIC_OFFSET_TABLE_REGNUM);
 463       rtx tmplrtx;
 464       char tmplab[20];
 465
 466       ASM_GENERATE_INTERNAL_LABEL(tmplab, "Lnlgr", ++n);
 467       tmplrtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (tmplab));
 468
 469       emit_insn (gen_reload_macho_picbase (tmplrtx));
 470       emit_move_insn (picreg, gen_rtx_REG (Pmode, LR_REGNO));
 471       emit_insn (gen_macho_correct_pic (picreg, picreg, picrtx, tmplrtx));
 472     }
 473   else
 474     /* Not using PIC reg, no reload needed.  */
 475     emit_note (NOTE_INSN_DELETED);
 476 #else
 477   gcc_unreachable ();
 478 #endif
 479   DONE;
 480 })