Nate Begeman | 21e463b | 2005-10-16 05:39:50 +0000 | [diff] [blame] | 1 | //===- PPCRegisterInfo.cpp - PowerPC Register Information -------*- C++ -*-===// |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 2 | // |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 7 | // |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
Dan Gohman | 6f0d024 | 2008-02-10 18:45:23 +0000 | [diff] [blame] | 10 | // This file contains the PowerPC implementation of the TargetRegisterInfo |
| 11 | // class. |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #define DEBUG_TYPE "reginfo" |
Chris Lattner | 2668959 | 2005-10-14 23:51:18 +0000 | [diff] [blame] | 16 | #include "PPC.h" |
Chris Lattner | 26bd0d4 | 2005-10-14 23:45:43 +0000 | [diff] [blame] | 17 | #include "PPCInstrBuilder.h" |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 18 | #include "PPCMachineFunctionInfo.h" |
Chris Lattner | 16e71f2 | 2005-10-14 23:59:06 +0000 | [diff] [blame] | 19 | #include "PPCRegisterInfo.h" |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 20 | #include "PPCFrameInfo.h" |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 21 | #include "PPCSubtarget.h" |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 22 | #include "llvm/CallingConv.h" |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 23 | #include "llvm/Constants.h" |
Dale Johannesen | 1532f3d | 2008-04-02 00:25:04 +0000 | [diff] [blame] | 24 | #include "llvm/Function.h" |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 25 | #include "llvm/Type.h" |
| 26 | #include "llvm/CodeGen/ValueTypes.h" |
| 27 | #include "llvm/CodeGen/MachineInstrBuilder.h" |
Jim Laskey | 44c3b9f | 2007-01-26 21:22:28 +0000 | [diff] [blame] | 28 | #include "llvm/CodeGen/MachineModuleInfo.h" |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 29 | #include "llvm/CodeGen/MachineFunction.h" |
| 30 | #include "llvm/CodeGen/MachineFrameInfo.h" |
Jim Laskey | f1d78e8 | 2006-03-23 18:12:57 +0000 | [diff] [blame] | 31 | #include "llvm/CodeGen/MachineLocation.h" |
Chris Lattner | 84bc542 | 2007-12-31 04:13:23 +0000 | [diff] [blame] | 32 | #include "llvm/CodeGen/MachineRegisterInfo.h" |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 33 | #include "llvm/CodeGen/RegisterScavenging.h" |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 34 | #include "llvm/Target/TargetFrameInfo.h" |
Chris Lattner | f9568d8 | 2006-04-17 21:48:13 +0000 | [diff] [blame] | 35 | #include "llvm/Target/TargetInstrInfo.h" |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 36 | #include "llvm/Target/TargetMachine.h" |
| 37 | #include "llvm/Target/TargetOptions.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 38 | #include "llvm/Support/CommandLine.h" |
| 39 | #include "llvm/Support/Debug.h" |
Nate Begeman | ae232e7 | 2005-11-06 09:00:38 +0000 | [diff] [blame] | 40 | #include "llvm/Support/MathExtras.h" |
Evan Cheng | b371f45 | 2007-02-19 21:49:54 +0000 | [diff] [blame] | 41 | #include "llvm/ADT/BitVector.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 42 | #include "llvm/ADT/STLExtras.h" |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 43 | #include <cstdlib> |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 44 | using namespace llvm; |
| 45 | |
Dale Johannesen | 82e4289 | 2008-03-10 22:59:46 +0000 | [diff] [blame] | 46 | // FIXME This disables some code that aligns the stack to a boundary |
| 47 | // bigger than the default (16 bytes on Darwin) when there is a stack local |
| 48 | // of greater alignment. This does not currently work, because the delta |
| 49 | // between old and new stack pointers is added to offsets that reference |
| 50 | // incoming parameters after the prolog is generated, and the code that |
| 51 | // does that doesn't handle a variable delta. You don't want to do that |
| 52 | // anyway; a better approach is to reserve another register that retains |
| 53 | // to the incoming stack pointer, and reference parameters relative to that. |
| 54 | #define ALIGN_STACK 0 |
| 55 | |
Bill Wendling | 880d0f6 | 2008-03-04 23:13:51 +0000 | [diff] [blame] | 56 | // FIXME (64-bit): Eventually enable by default. |
Bill Wendling | 4a66e9a | 2008-03-10 22:49:16 +0000 | [diff] [blame] | 57 | cl::opt<bool> EnablePPC32RS("enable-ppc32-regscavenger", |
| 58 | cl::init(false), |
| 59 | cl::desc("Enable PPC32 register scavenger"), |
| 60 | cl::Hidden); |
| 61 | cl::opt<bool> EnablePPC64RS("enable-ppc64-regscavenger", |
| 62 | cl::init(false), |
| 63 | cl::desc("Enable PPC64 register scavenger"), |
| 64 | cl::Hidden); |
| 65 | #define EnableRegisterScavenging \ |
| 66 | ((EnablePPC32RS && !Subtarget.isPPC64()) || \ |
| 67 | (EnablePPC64RS && Subtarget.isPPC64())) |
Bill Wendling | 880d0f6 | 2008-03-04 23:13:51 +0000 | [diff] [blame] | 68 | |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 69 | // FIXME (64-bit): Should be inlined. |
| 70 | bool |
| 71 | PPCRegisterInfo::requiresRegisterScavenging(const MachineFunction &) const { |
Bill Wendling | 4a66e9a | 2008-03-10 22:49:16 +0000 | [diff] [blame] | 72 | return EnableRegisterScavenging; |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 73 | } |
| 74 | |
Chris Lattner | 369503f | 2006-04-17 21:07:20 +0000 | [diff] [blame] | 75 | /// getRegisterNumbering - Given the enum value for some register, e.g. |
| 76 | /// PPC::F14, return the number that it corresponds to (e.g. 14). |
| 77 | unsigned PPCRegisterInfo::getRegisterNumbering(unsigned RegEnum) { |
Chris Lattner | be6a039 | 2006-07-11 20:53:55 +0000 | [diff] [blame] | 78 | using namespace PPC; |
Chris Lattner | 369503f | 2006-04-17 21:07:20 +0000 | [diff] [blame] | 79 | switch (RegEnum) { |
Chris Lattner | a1998d1 | 2008-02-13 17:24:14 +0000 | [diff] [blame] | 80 | case 0: return 0; |
Nicolas Geoffray | 0404cd9 | 2008-03-10 14:12:10 +0000 | [diff] [blame] | 81 | case R0 : case X0 : case F0 : case V0 : case CR0: case CR0LT: return 0; |
| 82 | case R1 : case X1 : case F1 : case V1 : case CR1: case CR0GT: return 1; |
| 83 | case R2 : case X2 : case F2 : case V2 : case CR2: case CR0EQ: return 2; |
| 84 | case R3 : case X3 : case F3 : case V3 : case CR3: case CR0UN: return 3; |
| 85 | case R4 : case X4 : case F4 : case V4 : case CR4: case CR1LT: return 4; |
| 86 | case R5 : case X5 : case F5 : case V5 : case CR5: case CR1GT: return 5; |
| 87 | case R6 : case X6 : case F6 : case V6 : case CR6: case CR1EQ: return 6; |
| 88 | case R7 : case X7 : case F7 : case V7 : case CR7: case CR1UN: return 7; |
| 89 | case R8 : case X8 : case F8 : case V8 : case CR2LT: return 8; |
| 90 | case R9 : case X9 : case F9 : case V9 : case CR2GT: return 9; |
| 91 | case R10: case X10: case F10: case V10: case CR2EQ: return 10; |
| 92 | case R11: case X11: case F11: case V11: case CR2UN: return 11; |
| 93 | case R12: case X12: case F12: case V12: case CR3LT: return 12; |
| 94 | case R13: case X13: case F13: case V13: case CR3GT: return 13; |
| 95 | case R14: case X14: case F14: case V14: case CR3EQ: return 14; |
| 96 | case R15: case X15: case F15: case V15: case CR3UN: return 15; |
| 97 | case R16: case X16: case F16: case V16: case CR4LT: return 16; |
| 98 | case R17: case X17: case F17: case V17: case CR4GT: return 17; |
| 99 | case R18: case X18: case F18: case V18: case CR4EQ: return 18; |
| 100 | case R19: case X19: case F19: case V19: case CR4UN: return 19; |
| 101 | case R20: case X20: case F20: case V20: case CR5LT: return 20; |
| 102 | case R21: case X21: case F21: case V21: case CR5GT: return 21; |
| 103 | case R22: case X22: case F22: case V22: case CR5EQ: return 22; |
| 104 | case R23: case X23: case F23: case V23: case CR5UN: return 23; |
| 105 | case R24: case X24: case F24: case V24: case CR6LT: return 24; |
| 106 | case R25: case X25: case F25: case V25: case CR6GT: return 25; |
| 107 | case R26: case X26: case F26: case V26: case CR6EQ: return 26; |
| 108 | case R27: case X27: case F27: case V27: case CR6UN: return 27; |
| 109 | case R28: case X28: case F28: case V28: case CR7LT: return 28; |
| 110 | case R29: case X29: case F29: case V29: case CR7GT: return 29; |
| 111 | case R30: case X30: case F30: case V30: case CR7EQ: return 30; |
| 112 | case R31: case X31: case F31: case V31: case CR7UN: return 31; |
Chris Lattner | be6a039 | 2006-07-11 20:53:55 +0000 | [diff] [blame] | 113 | default: |
Bill Wendling | f5da133 | 2006-12-07 22:21:48 +0000 | [diff] [blame] | 114 | cerr << "Unhandled reg in PPCRegisterInfo::getRegisterNumbering!\n"; |
Chris Lattner | be6a039 | 2006-07-11 20:53:55 +0000 | [diff] [blame] | 115 | abort(); |
Chris Lattner | 369503f | 2006-04-17 21:07:20 +0000 | [diff] [blame] | 116 | } |
| 117 | } |
| 118 | |
Evan Cheng | 7ce4578 | 2006-11-13 23:36:35 +0000 | [diff] [blame] | 119 | PPCRegisterInfo::PPCRegisterInfo(const PPCSubtarget &ST, |
| 120 | const TargetInstrInfo &tii) |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 121 | : PPCGenRegisterInfo(PPC::ADJCALLSTACKDOWN, PPC::ADJCALLSTACKUP), |
Evan Cheng | 7ce4578 | 2006-11-13 23:36:35 +0000 | [diff] [blame] | 122 | Subtarget(ST), TII(tii) { |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 123 | ImmToIdxMap[PPC::LD] = PPC::LDX; ImmToIdxMap[PPC::STD] = PPC::STDX; |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 124 | ImmToIdxMap[PPC::LBZ] = PPC::LBZX; ImmToIdxMap[PPC::STB] = PPC::STBX; |
| 125 | ImmToIdxMap[PPC::LHZ] = PPC::LHZX; ImmToIdxMap[PPC::LHA] = PPC::LHAX; |
| 126 | ImmToIdxMap[PPC::LWZ] = PPC::LWZX; ImmToIdxMap[PPC::LWA] = PPC::LWAX; |
| 127 | ImmToIdxMap[PPC::LFS] = PPC::LFSX; ImmToIdxMap[PPC::LFD] = PPC::LFDX; |
| 128 | ImmToIdxMap[PPC::STH] = PPC::STHX; ImmToIdxMap[PPC::STW] = PPC::STWX; |
| 129 | ImmToIdxMap[PPC::STFS] = PPC::STFSX; ImmToIdxMap[PPC::STFD] = PPC::STFDX; |
Nate Begeman | 1d9d742 | 2005-10-18 00:28:58 +0000 | [diff] [blame] | 130 | ImmToIdxMap[PPC::ADDI] = PPC::ADD4; |
Bill Wendling | 82d2514 | 2007-09-07 22:01:02 +0000 | [diff] [blame] | 131 | |
| 132 | // 64-bit |
| 133 | ImmToIdxMap[PPC::LHA8] = PPC::LHAX8; ImmToIdxMap[PPC::LBZ8] = PPC::LBZX8; |
| 134 | ImmToIdxMap[PPC::LHZ8] = PPC::LHZX8; ImmToIdxMap[PPC::LWZ8] = PPC::LWZX8; |
| 135 | ImmToIdxMap[PPC::STB8] = PPC::STBX8; ImmToIdxMap[PPC::STH8] = PPC::STHX8; |
| 136 | ImmToIdxMap[PPC::STW8] = PPC::STWX8; ImmToIdxMap[PPC::STDU] = PPC::STDUX; |
| 137 | ImmToIdxMap[PPC::ADDI8] = PPC::ADD8; ImmToIdxMap[PPC::STD_32] = PPC::STDX_32; |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 138 | } |
| 139 | |
Evan Cheng | 770bcc7 | 2009-02-06 17:43:24 +0000 | [diff] [blame] | 140 | /// getPointerRegClass - Return the register class to use to hold pointers. |
| 141 | /// This is used for addressing modes. |
| 142 | const TargetRegisterClass *PPCRegisterInfo::getPointerRegClass() const { |
| 143 | if (Subtarget.isPPC64()) |
| 144 | return &PPC::G8RCRegClass; |
| 145 | else |
| 146 | return &PPC::GPRCRegClass; |
| 147 | } |
| 148 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 149 | const unsigned* |
| 150 | PPCRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const { |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 151 | // 32-bit Darwin calling convention. |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 152 | static const unsigned Macho32_CalleeSavedRegs[] = { |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 153 | PPC::R13, PPC::R14, PPC::R15, |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 154 | PPC::R16, PPC::R17, PPC::R18, PPC::R19, |
| 155 | PPC::R20, PPC::R21, PPC::R22, PPC::R23, |
| 156 | PPC::R24, PPC::R25, PPC::R26, PPC::R27, |
| 157 | PPC::R28, PPC::R29, PPC::R30, PPC::R31, |
| 158 | |
| 159 | PPC::F14, PPC::F15, PPC::F16, PPC::F17, |
| 160 | PPC::F18, PPC::F19, PPC::F20, PPC::F21, |
| 161 | PPC::F22, PPC::F23, PPC::F24, PPC::F25, |
| 162 | PPC::F26, PPC::F27, PPC::F28, PPC::F29, |
Evan Cheng | 0f3ac8d | 2006-05-18 00:12:58 +0000 | [diff] [blame] | 163 | PPC::F30, PPC::F31, |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 164 | |
| 165 | PPC::CR2, PPC::CR3, PPC::CR4, |
| 166 | PPC::V20, PPC::V21, PPC::V22, PPC::V23, |
| 167 | PPC::V24, PPC::V25, PPC::V26, PPC::V27, |
| 168 | PPC::V28, PPC::V29, PPC::V30, PPC::V31, |
| 169 | |
Nicolas Geoffray | 0404cd9 | 2008-03-10 14:12:10 +0000 | [diff] [blame] | 170 | PPC::CR2LT, PPC::CR2GT, PPC::CR2EQ, PPC::CR2UN, |
| 171 | PPC::CR3LT, PPC::CR3GT, PPC::CR3EQ, PPC::CR3UN, |
| 172 | PPC::CR4LT, PPC::CR4GT, PPC::CR4EQ, PPC::CR4UN, |
| 173 | |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 174 | PPC::LR, 0 |
Evan Cheng | 0f3ac8d | 2006-05-18 00:12:58 +0000 | [diff] [blame] | 175 | }; |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 176 | |
| 177 | static const unsigned ELF32_CalleeSavedRegs[] = { |
| 178 | PPC::R13, PPC::R14, PPC::R15, |
| 179 | PPC::R16, PPC::R17, PPC::R18, PPC::R19, |
| 180 | PPC::R20, PPC::R21, PPC::R22, PPC::R23, |
| 181 | PPC::R24, PPC::R25, PPC::R26, PPC::R27, |
| 182 | PPC::R28, PPC::R29, PPC::R30, PPC::R31, |
| 183 | |
Nicolas Geoffray | ef3c030 | 2007-04-03 10:27:07 +0000 | [diff] [blame] | 184 | PPC::F9, |
| 185 | PPC::F10, PPC::F11, PPC::F12, PPC::F13, |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 186 | PPC::F14, PPC::F15, PPC::F16, PPC::F17, |
| 187 | PPC::F18, PPC::F19, PPC::F20, PPC::F21, |
| 188 | PPC::F22, PPC::F23, PPC::F24, PPC::F25, |
| 189 | PPC::F26, PPC::F27, PPC::F28, PPC::F29, |
| 190 | PPC::F30, PPC::F31, |
| 191 | |
| 192 | PPC::CR2, PPC::CR3, PPC::CR4, |
| 193 | PPC::V20, PPC::V21, PPC::V22, PPC::V23, |
| 194 | PPC::V24, PPC::V25, PPC::V26, PPC::V27, |
| 195 | PPC::V28, PPC::V29, PPC::V30, PPC::V31, |
| 196 | |
Nicolas Geoffray | 0404cd9 | 2008-03-10 14:12:10 +0000 | [diff] [blame] | 197 | PPC::CR2LT, PPC::CR2GT, PPC::CR2EQ, PPC::CR2UN, |
| 198 | PPC::CR3LT, PPC::CR3GT, PPC::CR3EQ, PPC::CR3UN, |
| 199 | PPC::CR4LT, PPC::CR4GT, PPC::CR4EQ, PPC::CR4UN, |
| 200 | |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 201 | PPC::LR, 0 |
| 202 | }; |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 203 | // 64-bit Darwin calling convention. |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 204 | static const unsigned Macho64_CalleeSavedRegs[] = { |
Chris Lattner | bdc571b | 2006-11-20 19:33:51 +0000 | [diff] [blame] | 205 | PPC::X14, PPC::X15, |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 206 | PPC::X16, PPC::X17, PPC::X18, PPC::X19, |
| 207 | PPC::X20, PPC::X21, PPC::X22, PPC::X23, |
| 208 | PPC::X24, PPC::X25, PPC::X26, PPC::X27, |
| 209 | PPC::X28, PPC::X29, PPC::X30, PPC::X31, |
| 210 | |
| 211 | PPC::F14, PPC::F15, PPC::F16, PPC::F17, |
| 212 | PPC::F18, PPC::F19, PPC::F20, PPC::F21, |
| 213 | PPC::F22, PPC::F23, PPC::F24, PPC::F25, |
| 214 | PPC::F26, PPC::F27, PPC::F28, PPC::F29, |
| 215 | PPC::F30, PPC::F31, |
| 216 | |
| 217 | PPC::CR2, PPC::CR3, PPC::CR4, |
| 218 | PPC::V20, PPC::V21, PPC::V22, PPC::V23, |
| 219 | PPC::V24, PPC::V25, PPC::V26, PPC::V27, |
| 220 | PPC::V28, PPC::V29, PPC::V30, PPC::V31, |
| 221 | |
Nicolas Geoffray | 0404cd9 | 2008-03-10 14:12:10 +0000 | [diff] [blame] | 222 | PPC::CR2LT, PPC::CR2GT, PPC::CR2EQ, PPC::CR2UN, |
| 223 | PPC::CR3LT, PPC::CR3GT, PPC::CR3EQ, PPC::CR3UN, |
| 224 | PPC::CR4LT, PPC::CR4GT, PPC::CR4EQ, PPC::CR4UN, |
| 225 | |
Chris Lattner | 6a5339b | 2006-11-14 18:44:47 +0000 | [diff] [blame] | 226 | PPC::LR8, 0 |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 227 | }; |
| 228 | |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 229 | if (Subtarget.isMachoABI()) |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 230 | return Subtarget.isPPC64() ? Macho64_CalleeSavedRegs : |
| 231 | Macho32_CalleeSavedRegs; |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 232 | |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 233 | // ELF 32. |
| 234 | return ELF32_CalleeSavedRegs; |
Evan Cheng | 0f3ac8d | 2006-05-18 00:12:58 +0000 | [diff] [blame] | 235 | } |
| 236 | |
| 237 | const TargetRegisterClass* const* |
Anton Korobeynikov | 2365f51 | 2007-07-14 14:06:15 +0000 | [diff] [blame] | 238 | PPCRegisterInfo::getCalleeSavedRegClasses(const MachineFunction *MF) const { |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 239 | // 32-bit Macho calling convention. |
| 240 | static const TargetRegisterClass * const Macho32_CalleeSavedRegClasses[] = { |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 241 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 242 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
| 243 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
| 244 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
| 245 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
| 246 | |
| 247 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 248 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 249 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 250 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 251 | &PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 252 | |
| 253 | &PPC::CRRCRegClass,&PPC::CRRCRegClass,&PPC::CRRCRegClass, |
| 254 | |
| 255 | &PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass, |
| 256 | &PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass, |
| 257 | &PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass, |
| 258 | |
Nicolas Geoffray | 0404cd9 | 2008-03-10 14:12:10 +0000 | [diff] [blame] | 259 | &PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass, |
| 260 | &PPC::CRBITRCRegClass, |
| 261 | &PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass, |
| 262 | &PPC::CRBITRCRegClass, |
| 263 | &PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass, |
| 264 | &PPC::CRBITRCRegClass, |
| 265 | |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 266 | &PPC::GPRCRegClass, 0 |
Evan Cheng | 0f3ac8d | 2006-05-18 00:12:58 +0000 | [diff] [blame] | 267 | }; |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 268 | |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 269 | static const TargetRegisterClass * const ELF32_CalleeSavedRegClasses[] = { |
| 270 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
| 271 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
| 272 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
| 273 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
| 274 | &PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass,&PPC::GPRCRegClass, |
| 275 | |
Nicolas Geoffray | cfcd8da | 2007-04-03 10:57:49 +0000 | [diff] [blame] | 276 | &PPC::F8RCRegClass, |
| 277 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 278 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 279 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 280 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 281 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 282 | &PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 283 | |
| 284 | &PPC::CRRCRegClass,&PPC::CRRCRegClass,&PPC::CRRCRegClass, |
| 285 | |
| 286 | &PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass, |
| 287 | &PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass, |
| 288 | &PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass, |
| 289 | |
Nicolas Geoffray | 0404cd9 | 2008-03-10 14:12:10 +0000 | [diff] [blame] | 290 | &PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass, |
| 291 | &PPC::CRBITRCRegClass, |
| 292 | &PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass, |
| 293 | &PPC::CRBITRCRegClass, |
| 294 | &PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass, |
| 295 | &PPC::CRBITRCRegClass, |
| 296 | |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 297 | &PPC::GPRCRegClass, 0 |
| 298 | }; |
| 299 | |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 300 | // 64-bit Macho calling convention. |
| 301 | static const TargetRegisterClass * const Macho64_CalleeSavedRegClasses[] = { |
Chris Lattner | bdc571b | 2006-11-20 19:33:51 +0000 | [diff] [blame] | 302 | &PPC::G8RCRegClass,&PPC::G8RCRegClass, |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 303 | &PPC::G8RCRegClass,&PPC::G8RCRegClass,&PPC::G8RCRegClass,&PPC::G8RCRegClass, |
| 304 | &PPC::G8RCRegClass,&PPC::G8RCRegClass,&PPC::G8RCRegClass,&PPC::G8RCRegClass, |
| 305 | &PPC::G8RCRegClass,&PPC::G8RCRegClass,&PPC::G8RCRegClass,&PPC::G8RCRegClass, |
| 306 | &PPC::G8RCRegClass,&PPC::G8RCRegClass,&PPC::G8RCRegClass,&PPC::G8RCRegClass, |
| 307 | |
| 308 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 309 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 310 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 311 | &PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 312 | &PPC::F8RCRegClass,&PPC::F8RCRegClass, |
| 313 | |
| 314 | &PPC::CRRCRegClass,&PPC::CRRCRegClass,&PPC::CRRCRegClass, |
| 315 | |
| 316 | &PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass, |
| 317 | &PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass, |
| 318 | &PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass,&PPC::VRRCRegClass, |
| 319 | |
Nicolas Geoffray | 0404cd9 | 2008-03-10 14:12:10 +0000 | [diff] [blame] | 320 | &PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass, |
| 321 | &PPC::CRBITRCRegClass, |
| 322 | &PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass, |
| 323 | &PPC::CRBITRCRegClass, |
| 324 | &PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass,&PPC::CRBITRCRegClass, |
| 325 | &PPC::CRBITRCRegClass, |
| 326 | |
Chris Lattner | 6a5339b | 2006-11-14 18:44:47 +0000 | [diff] [blame] | 327 | &PPC::G8RCRegClass, 0 |
Chris Lattner | 804e067 | 2006-07-11 00:48:23 +0000 | [diff] [blame] | 328 | }; |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 329 | |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 330 | if (Subtarget.isMachoABI()) |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 331 | return Subtarget.isPPC64() ? Macho64_CalleeSavedRegClasses : |
| 332 | Macho32_CalleeSavedRegClasses; |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 333 | |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 334 | // ELF 32. |
| 335 | return ELF32_CalleeSavedRegClasses; |
Evan Cheng | 0f3ac8d | 2006-05-18 00:12:58 +0000 | [diff] [blame] | 336 | } |
| 337 | |
Evan Cheng | b371f45 | 2007-02-19 21:49:54 +0000 | [diff] [blame] | 338 | // needsFP - Return true if the specified function should have a dedicated frame |
| 339 | // pointer register. This is true if the function has variable sized allocas or |
| 340 | // if frame pointer elimination is disabled. |
| 341 | // |
| 342 | static bool needsFP(const MachineFunction &MF) { |
| 343 | const MachineFrameInfo *MFI = MF.getFrameInfo(); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 344 | return NoFramePointerElim || MFI->hasVarSizedObjects() || |
| 345 | (PerformTailCallOpt && MF.getInfo<PPCFunctionInfo>()->hasFastCall()); |
Evan Cheng | b371f45 | 2007-02-19 21:49:54 +0000 | [diff] [blame] | 346 | } |
| 347 | |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 348 | static bool spillsCR(const MachineFunction &MF) { |
| 349 | const PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>(); |
| 350 | return FuncInfo->isCRSpilled(); |
| 351 | } |
| 352 | |
Evan Cheng | b371f45 | 2007-02-19 21:49:54 +0000 | [diff] [blame] | 353 | BitVector PPCRegisterInfo::getReservedRegs(const MachineFunction &MF) const { |
| 354 | BitVector Reserved(getNumRegs()); |
| 355 | Reserved.set(PPC::R0); |
| 356 | Reserved.set(PPC::R1); |
| 357 | Reserved.set(PPC::LR); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 358 | Reserved.set(PPC::LR8); |
Dale Johannesen | b384ab9 | 2008-10-29 18:26:45 +0000 | [diff] [blame] | 359 | Reserved.set(PPC::RM); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 360 | |
Evan Cheng | b371f45 | 2007-02-19 21:49:54 +0000 | [diff] [blame] | 361 | // In Linux, r2 is reserved for the OS. |
| 362 | if (!Subtarget.isDarwin()) |
| 363 | Reserved.set(PPC::R2); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 364 | |
| 365 | // On PPC64, r13 is the thread pointer. Never allocate this register. Note |
| 366 | // that this is over conservative, as it also prevents allocation of R31 when |
| 367 | // the FP is not needed. |
Evan Cheng | b371f45 | 2007-02-19 21:49:54 +0000 | [diff] [blame] | 368 | if (Subtarget.isPPC64()) { |
| 369 | Reserved.set(PPC::R13); |
| 370 | Reserved.set(PPC::R31); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 371 | |
Bill Wendling | 4a66e9a | 2008-03-10 22:49:16 +0000 | [diff] [blame] | 372 | if (!EnableRegisterScavenging) |
Bill Wendling | 880d0f6 | 2008-03-04 23:13:51 +0000 | [diff] [blame] | 373 | Reserved.set(PPC::R0); // FIXME (64-bit): Remove |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 374 | |
| 375 | Reserved.set(PPC::X0); |
| 376 | Reserved.set(PPC::X1); |
| 377 | Reserved.set(PPC::X13); |
| 378 | Reserved.set(PPC::X31); |
Evan Cheng | b371f45 | 2007-02-19 21:49:54 +0000 | [diff] [blame] | 379 | } |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 380 | |
Evan Cheng | b371f45 | 2007-02-19 21:49:54 +0000 | [diff] [blame] | 381 | if (needsFP(MF)) |
| 382 | Reserved.set(PPC::R31); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 383 | |
Evan Cheng | b371f45 | 2007-02-19 21:49:54 +0000 | [diff] [blame] | 384 | return Reserved; |
| 385 | } |
| 386 | |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 387 | //===----------------------------------------------------------------------===// |
| 388 | // Stack Frame Processing methods |
| 389 | //===----------------------------------------------------------------------===// |
| 390 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 391 | // hasFP - Return true if the specified function actually has a dedicated frame |
| 392 | // pointer register. This is true if the function needs a frame pointer and has |
| 393 | // a non-zero stack size. |
Evan Cheng | dc77540 | 2007-01-23 00:57:47 +0000 | [diff] [blame] | 394 | bool PPCRegisterInfo::hasFP(const MachineFunction &MF) const { |
Chris Lattner | 4f91a4c | 2006-04-03 22:03:29 +0000 | [diff] [blame] | 395 | const MachineFrameInfo *MFI = MF.getFrameInfo(); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 396 | return MFI->getStackSize() && needsFP(MF); |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 397 | } |
| 398 | |
Chris Lattner | 73944fb | 2007-12-08 06:39:11 +0000 | [diff] [blame] | 399 | /// MustSaveLR - Return true if this function requires that we save the LR |
Chris Lattner | 3fc027d | 2007-12-08 06:59:59 +0000 | [diff] [blame] | 400 | /// register onto the stack in the prolog and restore it in the epilog of the |
| 401 | /// function. |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 402 | static bool MustSaveLR(const MachineFunction &MF, unsigned LR) { |
Chris Lattner | 3fc027d | 2007-12-08 06:59:59 +0000 | [diff] [blame] | 403 | const PPCFunctionInfo *MFI = MF.getInfo<PPCFunctionInfo>(); |
| 404 | |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 405 | // We need a save/restore of LR if there is any def of LR (which is |
| 406 | // defined by calls, including the PIC setup sequence), or if there is |
| 407 | // some use of the LR stack slot (e.g. for builtin_return_address). |
| 408 | // (LR comes in 32 and 64 bit versions.) |
| 409 | MachineRegisterInfo::def_iterator RI = MF.getRegInfo().def_begin(LR); |
| 410 | return RI !=MF.getRegInfo().def_end() || MFI->isLRStoreRequired(); |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 411 | } |
| 412 | |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 413 | |
| 414 | |
Nate Begeman | 21e463b | 2005-10-16 05:39:50 +0000 | [diff] [blame] | 415 | void PPCRegisterInfo:: |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 416 | eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, |
| 417 | MachineBasicBlock::iterator I) const { |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 418 | if (PerformTailCallOpt && I->getOpcode() == PPC::ADJCALLSTACKUP) { |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 419 | // Add (actually subtract) back the amount the callee popped on return. |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 420 | if (int CalleeAmt = I->getOperand(1).getImm()) { |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 421 | bool is64Bit = Subtarget.isPPC64(); |
| 422 | CalleeAmt *= -1; |
| 423 | unsigned StackReg = is64Bit ? PPC::X1 : PPC::R1; |
| 424 | unsigned TmpReg = is64Bit ? PPC::X0 : PPC::R0; |
| 425 | unsigned ADDIInstr = is64Bit ? PPC::ADDI8 : PPC::ADDI; |
| 426 | unsigned ADDInstr = is64Bit ? PPC::ADD8 : PPC::ADD4; |
| 427 | unsigned LISInstr = is64Bit ? PPC::LIS8 : PPC::LIS; |
| 428 | unsigned ORIInstr = is64Bit ? PPC::ORI8 : PPC::ORI; |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 429 | MachineInstr *MI = I; |
| 430 | DebugLoc dl = MI->getDebugLoc(); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 431 | |
| 432 | if (isInt16(CalleeAmt)) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 433 | BuildMI(MBB, I, dl, TII.get(ADDIInstr), StackReg).addReg(StackReg). |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 434 | addImm(CalleeAmt); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 435 | } else { |
| 436 | MachineBasicBlock::iterator MBBI = I; |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 437 | BuildMI(MBB, MBBI, dl, TII.get(LISInstr), TmpReg) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 438 | .addImm(CalleeAmt >> 16); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 439 | BuildMI(MBB, MBBI, dl, TII.get(ORIInstr), TmpReg) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 440 | .addReg(TmpReg, RegState::Kill) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 441 | .addImm(CalleeAmt & 0xFFFF); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 442 | BuildMI(MBB, MBBI, dl, TII.get(ADDInstr)) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 443 | .addReg(StackReg) |
| 444 | .addReg(StackReg) |
| 445 | .addReg(TmpReg); |
| 446 | } |
| 447 | } |
| 448 | } |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 449 | // Simply discard ADJCALLSTACKDOWN, ADJCALLSTACKUP instructions. |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 450 | MBB.erase(I); |
| 451 | } |
| 452 | |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 453 | /// findScratchRegister - Find a 'free' PPC register. Try for a call-clobbered |
| 454 | /// register first and then a spilled callee-saved register if that fails. |
| 455 | static |
| 456 | unsigned findScratchRegister(MachineBasicBlock::iterator II, RegScavenger *RS, |
| 457 | const TargetRegisterClass *RC, int SPAdj) { |
| 458 | assert(RS && "Register scavenging must be on"); |
| 459 | unsigned Reg = RS->FindUnusedReg(RC, true); |
| 460 | // FIXME: move ARM callee-saved reg scan to target independent code, then |
| 461 | // search for already spilled CS register here. |
| 462 | if (Reg == 0) |
| 463 | Reg = RS->scavengeRegister(RC, II, SPAdj); |
| 464 | return Reg; |
| 465 | } |
| 466 | |
| 467 | /// lowerDynamicAlloc - Generate the code for allocating an object in the |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 468 | /// current frame. The sequence of code with be in the general form |
| 469 | /// |
Dan Gohman | 0f8b53f | 2009-03-03 02:55:14 +0000 | [diff] [blame] | 470 | /// addi R0, SP, \#frameSize ; get the address of the previous frame |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 471 | /// stwxu R0, SP, Rnegsize ; add and update the SP with the negated size |
Dan Gohman | 0f8b53f | 2009-03-03 02:55:14 +0000 | [diff] [blame] | 472 | /// addi Rnew, SP, \#maxCalFrameSize ; get the top of the allocation |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 473 | /// |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 474 | void PPCRegisterInfo::lowerDynamicAlloc(MachineBasicBlock::iterator II, |
| 475 | int SPAdj, RegScavenger *RS) const { |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 476 | // Get the instruction. |
| 477 | MachineInstr &MI = *II; |
| 478 | // Get the instruction's basic block. |
| 479 | MachineBasicBlock &MBB = *MI.getParent(); |
| 480 | // Get the basic block's function. |
| 481 | MachineFunction &MF = *MBB.getParent(); |
| 482 | // Get the frame info. |
| 483 | MachineFrameInfo *MFI = MF.getFrameInfo(); |
| 484 | // Determine whether 64-bit pointers are used. |
| 485 | bool LP64 = Subtarget.isPPC64(); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 486 | DebugLoc dl = MI.getDebugLoc(); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 487 | |
Evan Cheng | fab0439 | 2007-01-25 22:48:25 +0000 | [diff] [blame] | 488 | // Get the maximum call stack size. |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 489 | unsigned maxCallFrameSize = MFI->getMaxCallFrameSize(); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 490 | // Get the total frame size. |
| 491 | unsigned FrameSize = MFI->getStackSize(); |
| 492 | |
| 493 | // Get stack alignments. |
| 494 | unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment(); |
| 495 | unsigned MaxAlign = MFI->getMaxAlignment(); |
Jim Laskey | d6fa8c1 | 2006-11-17 18:49:39 +0000 | [diff] [blame] | 496 | assert(MaxAlign <= TargetAlign && |
| 497 | "Dynamic alloca with large aligns not supported"); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 498 | |
| 499 | // Determine the previous frame's address. If FrameSize can't be |
| 500 | // represented as 16 bits or we need special alignment, then we load the |
| 501 | // previous frame's address from 0(SP). Why not do an addis of the hi? |
| 502 | // Because R0 is our only safe tmp register and addi/addis treat R0 as zero. |
| 503 | // Constructing the constant and adding would take 3 instructions. |
| 504 | // Fortunately, a frame greater than 32K is rare. |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 505 | const TargetRegisterClass *G8RC = &PPC::G8RCRegClass; |
| 506 | const TargetRegisterClass *GPRC = &PPC::GPRCRegClass; |
| 507 | const TargetRegisterClass *RC = LP64 ? G8RC : GPRC; |
| 508 | |
| 509 | // FIXME (64-bit): Use "findScratchRegister" |
| 510 | unsigned Reg; |
Bill Wendling | 4a66e9a | 2008-03-10 22:49:16 +0000 | [diff] [blame] | 511 | if (EnableRegisterScavenging) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 512 | Reg = findScratchRegister(II, RS, RC, SPAdj); |
| 513 | else |
| 514 | Reg = PPC::R0; |
| 515 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 516 | if (MaxAlign < TargetAlign && isInt16(FrameSize)) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 517 | BuildMI(MBB, II, dl, TII.get(PPC::ADDI), Reg) |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 518 | .addReg(PPC::R31) |
| 519 | .addImm(FrameSize); |
| 520 | } else if (LP64) { |
Bill Wendling | 4a66e9a | 2008-03-10 22:49:16 +0000 | [diff] [blame] | 521 | if (EnableRegisterScavenging) // FIXME (64-bit): Use "true" part. |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 522 | BuildMI(MBB, II, dl, TII.get(PPC::LD), Reg) |
Chris Lattner | 71a2cb2 | 2008-03-20 01:22:40 +0000 | [diff] [blame] | 523 | .addImm(0) |
| 524 | .addReg(PPC::X1); |
Bill Wendling | 880d0f6 | 2008-03-04 23:13:51 +0000 | [diff] [blame] | 525 | else |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 526 | BuildMI(MBB, II, dl, TII.get(PPC::LD), PPC::X0) |
Chris Lattner | 71a2cb2 | 2008-03-20 01:22:40 +0000 | [diff] [blame] | 527 | .addImm(0) |
| 528 | .addReg(PPC::X1); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 529 | } else { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 530 | BuildMI(MBB, II, dl, TII.get(PPC::LWZ), Reg) |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 531 | .addImm(0) |
| 532 | .addReg(PPC::R1); |
| 533 | } |
| 534 | |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 535 | // Grow the stack and update the stack pointer link, then determine the |
| 536 | // address of new allocated space. |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 537 | if (LP64) { |
Bill Wendling | 4a66e9a | 2008-03-10 22:49:16 +0000 | [diff] [blame] | 538 | if (EnableRegisterScavenging) // FIXME (64-bit): Use "true" part. |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 539 | BuildMI(MBB, II, dl, TII.get(PPC::STDUX)) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 540 | .addReg(Reg, RegState::Kill) |
Chris Lattner | 71a2cb2 | 2008-03-20 01:22:40 +0000 | [diff] [blame] | 541 | .addReg(PPC::X1) |
| 542 | .addReg(MI.getOperand(1).getReg()); |
Bill Wendling | 880d0f6 | 2008-03-04 23:13:51 +0000 | [diff] [blame] | 543 | else |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 544 | BuildMI(MBB, II, dl, TII.get(PPC::STDUX)) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 545 | .addReg(PPC::X0, RegState::Kill) |
Chris Lattner | 71a2cb2 | 2008-03-20 01:22:40 +0000 | [diff] [blame] | 546 | .addReg(PPC::X1) |
| 547 | .addReg(MI.getOperand(1).getReg()); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 548 | |
| 549 | if (!MI.getOperand(1).isKill()) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 550 | BuildMI(MBB, II, dl, TII.get(PPC::ADDI8), MI.getOperand(0).getReg()) |
Chris Lattner | 71a2cb2 | 2008-03-20 01:22:40 +0000 | [diff] [blame] | 551 | .addReg(PPC::X1) |
| 552 | .addImm(maxCallFrameSize); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 553 | else |
| 554 | // Implicitly kill the register. |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 555 | BuildMI(MBB, II, dl, TII.get(PPC::ADDI8), MI.getOperand(0).getReg()) |
Chris Lattner | 71a2cb2 | 2008-03-20 01:22:40 +0000 | [diff] [blame] | 556 | .addReg(PPC::X1) |
| 557 | .addImm(maxCallFrameSize) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 558 | .addReg(MI.getOperand(1).getReg(), RegState::ImplicitKill); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 559 | } else { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 560 | BuildMI(MBB, II, dl, TII.get(PPC::STWUX)) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 561 | .addReg(Reg, RegState::Kill) |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 562 | .addReg(PPC::R1) |
| 563 | .addReg(MI.getOperand(1).getReg()); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 564 | |
| 565 | if (!MI.getOperand(1).isKill()) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 566 | BuildMI(MBB, II, dl, TII.get(PPC::ADDI), MI.getOperand(0).getReg()) |
Chris Lattner | 71a2cb2 | 2008-03-20 01:22:40 +0000 | [diff] [blame] | 567 | .addReg(PPC::R1) |
| 568 | .addImm(maxCallFrameSize); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 569 | else |
| 570 | // Implicitly kill the register. |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 571 | BuildMI(MBB, II, dl, TII.get(PPC::ADDI), MI.getOperand(0).getReg()) |
Chris Lattner | 71a2cb2 | 2008-03-20 01:22:40 +0000 | [diff] [blame] | 572 | .addReg(PPC::R1) |
| 573 | .addImm(maxCallFrameSize) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 574 | .addReg(MI.getOperand(1).getReg(), RegState::ImplicitKill); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 575 | } |
| 576 | |
| 577 | // Discard the DYNALLOC instruction. |
| 578 | MBB.erase(II); |
| 579 | } |
| 580 | |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 581 | /// lowerCRSpilling - Generate the code for spilling a CR register. Instead of |
| 582 | /// reserving a whole register (R0), we scrounge for one here. This generates |
| 583 | /// code like this: |
| 584 | /// |
| 585 | /// mfcr rA ; Move the conditional register into GPR rA. |
| 586 | /// rlwinm rA, rA, SB, 0, 31 ; Shift the bits left so they are in CR0's slot. |
| 587 | /// stw rA, FI ; Store rA to the frame. |
| 588 | /// |
| 589 | void PPCRegisterInfo::lowerCRSpilling(MachineBasicBlock::iterator II, |
| 590 | unsigned FrameIndex, int SPAdj, |
| 591 | RegScavenger *RS) const { |
| 592 | // Get the instruction. |
| 593 | MachineInstr &MI = *II; // ; SPILL_CR <SrcReg>, <offset>, <FI> |
| 594 | // Get the instruction's basic block. |
| 595 | MachineBasicBlock &MBB = *MI.getParent(); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 596 | DebugLoc dl = MI.getDebugLoc(); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 597 | |
| 598 | const TargetRegisterClass *G8RC = &PPC::G8RCRegClass; |
| 599 | const TargetRegisterClass *GPRC = &PPC::GPRCRegClass; |
| 600 | const TargetRegisterClass *RC = Subtarget.isPPC64() ? G8RC : GPRC; |
| 601 | unsigned Reg = findScratchRegister(II, RS, RC, SPAdj); |
| 602 | |
Bill Wendling | 2b5fab6 | 2008-03-04 23:27:33 +0000 | [diff] [blame] | 603 | // We need to store the CR in the low 4-bits of the saved value. First, issue |
| 604 | // an MFCR to save all of the CRBits. Add an implicit kill of the CR. |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 605 | if (!MI.getOperand(0).isKill()) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 606 | BuildMI(MBB, II, dl, TII.get(PPC::MFCR), Reg); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 607 | else |
| 608 | // Implicitly kill the CR register. |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 609 | BuildMI(MBB, II, dl, TII.get(PPC::MFCR), Reg) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 610 | .addReg(MI.getOperand(0).getReg(), RegState::ImplicitKill); |
Bill Wendling | 2b5fab6 | 2008-03-04 23:27:33 +0000 | [diff] [blame] | 611 | |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 612 | // If the saved register wasn't CR0, shift the bits left so that they are in |
| 613 | // CR0's slot. |
| 614 | unsigned SrcReg = MI.getOperand(0).getReg(); |
| 615 | if (SrcReg != PPC::CR0) |
| 616 | // rlwinm rA, rA, ShiftBits, 0, 31. |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 617 | BuildMI(MBB, II, dl, TII.get(PPC::RLWINM), Reg) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 618 | .addReg(Reg, RegState::Kill) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 619 | .addImm(PPCRegisterInfo::getRegisterNumbering(SrcReg) * 4) |
| 620 | .addImm(0) |
| 621 | .addImm(31); |
| 622 | |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 623 | addFrameReference(BuildMI(MBB, II, dl, TII.get(PPC::STW)) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 624 | .addReg(Reg, getKillRegState(MI.getOperand(1).getImm())), |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 625 | FrameIndex); |
| 626 | |
| 627 | // Discard the pseudo instruction. |
| 628 | MBB.erase(II); |
| 629 | } |
| 630 | |
Evan Cheng | 5e6df46 | 2007-02-28 00:21:17 +0000 | [diff] [blame] | 631 | void PPCRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II, |
Evan Cheng | 97de913 | 2007-05-01 09:13:03 +0000 | [diff] [blame] | 632 | int SPAdj, RegScavenger *RS) const { |
| 633 | assert(SPAdj == 0 && "Unexpected"); |
| 634 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 635 | // Get the instruction. |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 636 | MachineInstr &MI = *II; |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 637 | // Get the instruction's basic block. |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 638 | MachineBasicBlock &MBB = *MI.getParent(); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 639 | // Get the basic block's function. |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 640 | MachineFunction &MF = *MBB.getParent(); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 641 | // Get the frame info. |
| 642 | MachineFrameInfo *MFI = MF.getFrameInfo(); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 643 | DebugLoc dl = MI.getDebugLoc(); |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 644 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 645 | // Find out which operand is the frame index. |
Chris Lattner | f602a25 | 2007-10-16 18:00:18 +0000 | [diff] [blame] | 646 | unsigned FIOperandNo = 0; |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 647 | while (!MI.getOperand(FIOperandNo).isFI()) { |
Chris Lattner | f602a25 | 2007-10-16 18:00:18 +0000 | [diff] [blame] | 648 | ++FIOperandNo; |
| 649 | assert(FIOperandNo != MI.getNumOperands() && |
| 650 | "Instr doesn't have FrameIndex operand!"); |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 651 | } |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 652 | // Take into account whether it's an add or mem instruction |
Chris Lattner | f602a25 | 2007-10-16 18:00:18 +0000 | [diff] [blame] | 653 | unsigned OffsetOperandNo = (FIOperandNo == 2) ? 1 : 2; |
Chris Lattner | 9aa2895 | 2007-02-01 00:39:08 +0000 | [diff] [blame] | 654 | if (MI.getOpcode() == TargetInstrInfo::INLINEASM) |
Chris Lattner | f602a25 | 2007-10-16 18:00:18 +0000 | [diff] [blame] | 655 | OffsetOperandNo = FIOperandNo-1; |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 656 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 657 | // Get the frame index. |
Chris Lattner | 8aa797a | 2007-12-30 23:10:15 +0000 | [diff] [blame] | 658 | int FrameIndex = MI.getOperand(FIOperandNo).getIndex(); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 659 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 660 | // Get the frame pointer save index. Users of this index are primarily |
| 661 | // DYNALLOC instructions. |
| 662 | PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>(); |
| 663 | int FPSI = FI->getFramePointerSaveIndex(); |
| 664 | // Get the instruction opcode. |
| 665 | unsigned OpC = MI.getOpcode(); |
| 666 | |
| 667 | // Special case for dynamic alloca. |
| 668 | if (FPSI && FrameIndex == FPSI && |
| 669 | (OpC == PPC::DYNALLOC || OpC == PPC::DYNALLOC8)) { |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 670 | lowerDynamicAlloc(II, SPAdj, RS); |
| 671 | return; |
| 672 | } |
| 673 | |
| 674 | // Special case for pseudo-op SPILL_CR. |
Bill Wendling | 4a66e9a | 2008-03-10 22:49:16 +0000 | [diff] [blame] | 675 | if (EnableRegisterScavenging) // FIXME (64-bit): Enable by default. |
Bill Wendling | 880d0f6 | 2008-03-04 23:13:51 +0000 | [diff] [blame] | 676 | if (OpC == PPC::SPILL_CR) { |
| 677 | lowerCRSpilling(II, FrameIndex, SPAdj, RS); |
| 678 | return; |
| 679 | } |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 680 | |
| 681 | // Replace the FrameIndex with base register with GPR1 (SP) or GPR31 (FP). |
Chris Lattner | f602a25 | 2007-10-16 18:00:18 +0000 | [diff] [blame] | 682 | MI.getOperand(FIOperandNo).ChangeToRegister(hasFP(MF) ? PPC::R31 : PPC::R1, |
| 683 | false); |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 684 | |
Chris Lattner | 7ffa9ab | 2006-06-27 18:55:49 +0000 | [diff] [blame] | 685 | // Figure out if the offset in the instruction is shifted right two bits. This |
| 686 | // is true for instructions like "STD", which the machine implicitly adds two |
| 687 | // low zeros to. |
| 688 | bool isIXAddr = false; |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 689 | switch (OpC) { |
Chris Lattner | 7ffa9ab | 2006-06-27 18:55:49 +0000 | [diff] [blame] | 690 | case PPC::LWA: |
| 691 | case PPC::LD: |
| 692 | case PPC::STD: |
| 693 | case PPC::STD_32: |
| 694 | isIXAddr = true; |
| 695 | break; |
| 696 | } |
| 697 | |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 698 | // Now add the frame object offset to the offset from r1. |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 699 | int Offset = MFI->getObjectOffset(FrameIndex); |
Chris Lattner | 7ffa9ab | 2006-06-27 18:55:49 +0000 | [diff] [blame] | 700 | if (!isIXAddr) |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 701 | Offset += MI.getOperand(OffsetOperandNo).getImm(); |
Chris Lattner | 7ffa9ab | 2006-06-27 18:55:49 +0000 | [diff] [blame] | 702 | else |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 703 | Offset += MI.getOperand(OffsetOperandNo).getImm() << 2; |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 704 | |
| 705 | // If we're not using a Frame Pointer that has been set to the value of the |
| 706 | // SP before having the stack size subtracted from it, then add the stack size |
| 707 | // to Offset to get the correct offset. |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 708 | Offset += MFI->getStackSize(); |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 709 | |
Chris Lattner | 789db09 | 2007-11-27 22:14:42 +0000 | [diff] [blame] | 710 | // If we can, encode the offset directly into the instruction. If this is a |
| 711 | // normal PPC "ri" instruction, any 16-bit value can be safely encoded. If |
| 712 | // this is a PPC64 "ix" instruction, only a 16-bit value with the low two bits |
| 713 | // clear can be encoded. This is extremely uncommon, because normally you |
| 714 | // only "std" to a stack slot that is at least 4-byte aligned, but it can |
| 715 | // happen in invalid code. |
Chris Lattner | d964285 | 2007-12-08 07:04:58 +0000 | [diff] [blame] | 716 | if (isInt16(Offset) && (!isIXAddr || (Offset & 3) == 0)) { |
Chris Lattner | 789db09 | 2007-11-27 22:14:42 +0000 | [diff] [blame] | 717 | if (isIXAddr) |
Chris Lattner | 841d12d | 2005-10-18 16:51:22 +0000 | [diff] [blame] | 718 | Offset >>= 2; // The actual encoded value has the low two bits zero. |
Chris Lattner | f602a25 | 2007-10-16 18:00:18 +0000 | [diff] [blame] | 719 | MI.getOperand(OffsetOperandNo).ChangeToImmediate(Offset); |
Chris Lattner | 789db09 | 2007-11-27 22:14:42 +0000 | [diff] [blame] | 720 | return; |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 721 | } |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 722 | |
| 723 | // The offset doesn't fit into a single register, scavenge one to build the |
| 724 | // offset in. |
| 725 | // FIXME: figure out what SPAdj is doing here. |
| 726 | |
| 727 | // FIXME (64-bit): Use "findScratchRegister". |
| 728 | unsigned SReg; |
Bill Wendling | 4a66e9a | 2008-03-10 22:49:16 +0000 | [diff] [blame] | 729 | if (EnableRegisterScavenging) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 730 | SReg = findScratchRegister(II, RS, &PPC::GPRCRegClass, SPAdj); |
| 731 | else |
| 732 | SReg = PPC::R0; |
| 733 | |
| 734 | // Insert a set of rA with the full offset value before the ld, st, or add |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 735 | BuildMI(MBB, II, dl, TII.get(PPC::LIS), SReg) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 736 | .addImm(Offset >> 16); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 737 | BuildMI(MBB, II, dl, TII.get(PPC::ORI), SReg) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 738 | .addReg(SReg, RegState::Kill) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 739 | .addImm(Offset); |
| 740 | |
| 741 | // Convert into indexed form of the instruction: |
| 742 | // |
| 743 | // sth 0:rA, 1:imm 2:(rB) ==> sthx 0:rA, 2:rB, 1:r0 |
| 744 | // addi 0:rA 1:rB, 2, imm ==> add 0:rA, 1:rB, 2:r0 |
Chris Lattner | 789db09 | 2007-11-27 22:14:42 +0000 | [diff] [blame] | 745 | unsigned OperandBase; |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 746 | |
Chris Lattner | 789db09 | 2007-11-27 22:14:42 +0000 | [diff] [blame] | 747 | if (OpC != TargetInstrInfo::INLINEASM) { |
| 748 | assert(ImmToIdxMap.count(OpC) && |
| 749 | "No indexed form of load or store available!"); |
| 750 | unsigned NewOpcode = ImmToIdxMap.find(OpC)->second; |
Chris Lattner | 5080f4d | 2008-01-11 18:10:50 +0000 | [diff] [blame] | 751 | MI.setDesc(TII.get(NewOpcode)); |
Chris Lattner | 789db09 | 2007-11-27 22:14:42 +0000 | [diff] [blame] | 752 | OperandBase = 1; |
| 753 | } else { |
| 754 | OperandBase = OffsetOperandNo; |
| 755 | } |
| 756 | |
| 757 | unsigned StackReg = MI.getOperand(FIOperandNo).getReg(); |
| 758 | MI.getOperand(OperandBase).ChangeToRegister(StackReg, false); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 759 | MI.getOperand(OperandBase + 1).ChangeToRegister(SReg, false); |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 760 | } |
| 761 | |
Chris Lattner | f7d2372 | 2006-04-17 20:59:25 +0000 | [diff] [blame] | 762 | /// VRRegNo - Map from a numbered VR register to its enum value. |
| 763 | /// |
| 764 | static const unsigned short VRRegNo[] = { |
Chris Lattner | b47e089 | 2006-06-12 21:50:57 +0000 | [diff] [blame] | 765 | PPC::V0 , PPC::V1 , PPC::V2 , PPC::V3 , PPC::V4 , PPC::V5 , PPC::V6 , PPC::V7 , |
| 766 | PPC::V8 , PPC::V9 , PPC::V10, PPC::V11, PPC::V12, PPC::V13, PPC::V14, PPC::V15, |
Chris Lattner | f7d2372 | 2006-04-17 20:59:25 +0000 | [diff] [blame] | 767 | PPC::V16, PPC::V17, PPC::V18, PPC::V19, PPC::V20, PPC::V21, PPC::V22, PPC::V23, |
| 768 | PPC::V24, PPC::V25, PPC::V26, PPC::V27, PPC::V28, PPC::V29, PPC::V30, PPC::V31 |
| 769 | }; |
| 770 | |
Chris Lattner | f9568d8 | 2006-04-17 21:48:13 +0000 | [diff] [blame] | 771 | /// RemoveVRSaveCode - We have found that this function does not need any code |
| 772 | /// to manipulate the VRSAVE register, even though it uses vector registers. |
| 773 | /// This can happen when the only registers used are known to be live in or out |
| 774 | /// of the function. Remove all of the VRSAVE related code from the function. |
| 775 | static void RemoveVRSaveCode(MachineInstr *MI) { |
| 776 | MachineBasicBlock *Entry = MI->getParent(); |
| 777 | MachineFunction *MF = Entry->getParent(); |
| 778 | |
| 779 | // We know that the MTVRSAVE instruction immediately follows MI. Remove it. |
| 780 | MachineBasicBlock::iterator MBBI = MI; |
| 781 | ++MBBI; |
| 782 | assert(MBBI != Entry->end() && MBBI->getOpcode() == PPC::MTVRSAVE); |
| 783 | MBBI->eraseFromParent(); |
| 784 | |
| 785 | bool RemovedAllMTVRSAVEs = true; |
| 786 | // See if we can find and remove the MTVRSAVE instruction from all of the |
| 787 | // epilog blocks. |
Chris Lattner | f9568d8 | 2006-04-17 21:48:13 +0000 | [diff] [blame] | 788 | for (MachineFunction::iterator I = MF->begin(), E = MF->end(); I != E; ++I) { |
| 789 | // If last instruction is a return instruction, add an epilogue |
Chris Lattner | 749c6f6 | 2008-01-07 07:27:27 +0000 | [diff] [blame] | 790 | if (!I->empty() && I->back().getDesc().isReturn()) { |
Chris Lattner | f9568d8 | 2006-04-17 21:48:13 +0000 | [diff] [blame] | 791 | bool FoundIt = false; |
| 792 | for (MBBI = I->end(); MBBI != I->begin(); ) { |
| 793 | --MBBI; |
| 794 | if (MBBI->getOpcode() == PPC::MTVRSAVE) { |
| 795 | MBBI->eraseFromParent(); // remove it. |
| 796 | FoundIt = true; |
| 797 | break; |
| 798 | } |
| 799 | } |
| 800 | RemovedAllMTVRSAVEs &= FoundIt; |
| 801 | } |
| 802 | } |
| 803 | |
| 804 | // If we found and removed all MTVRSAVE instructions, remove the read of |
| 805 | // VRSAVE as well. |
| 806 | if (RemovedAllMTVRSAVEs) { |
| 807 | MBBI = MI; |
| 808 | assert(MBBI != Entry->begin() && "UPDATE_VRSAVE is first instr in block?"); |
| 809 | --MBBI; |
| 810 | assert(MBBI->getOpcode() == PPC::MFVRSAVE && "VRSAVE instrs wandered?"); |
| 811 | MBBI->eraseFromParent(); |
| 812 | } |
| 813 | |
| 814 | // Finally, nuke the UPDATE_VRSAVE. |
| 815 | MI->eraseFromParent(); |
| 816 | } |
| 817 | |
Chris Lattner | 1877ec9 | 2006-03-13 21:52:10 +0000 | [diff] [blame] | 818 | // HandleVRSaveUpdate - MI is the UPDATE_VRSAVE instruction introduced by the |
| 819 | // instruction selector. Based on the vector registers that have been used, |
| 820 | // transform this into the appropriate ORI instruction. |
Evan Cheng | 6c087e5 | 2007-04-25 22:13:27 +0000 | [diff] [blame] | 821 | static void HandleVRSaveUpdate(MachineInstr *MI, const TargetInstrInfo &TII) { |
| 822 | MachineFunction *MF = MI->getParent()->getParent(); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 823 | DebugLoc dl = MI->getDebugLoc(); |
Evan Cheng | 6c087e5 | 2007-04-25 22:13:27 +0000 | [diff] [blame] | 824 | |
Chris Lattner | 1877ec9 | 2006-03-13 21:52:10 +0000 | [diff] [blame] | 825 | unsigned UsedRegMask = 0; |
Chris Lattner | f7d2372 | 2006-04-17 20:59:25 +0000 | [diff] [blame] | 826 | for (unsigned i = 0; i != 32; ++i) |
Chris Lattner | 84bc542 | 2007-12-31 04:13:23 +0000 | [diff] [blame] | 827 | if (MF->getRegInfo().isPhysRegUsed(VRRegNo[i])) |
Chris Lattner | f7d2372 | 2006-04-17 20:59:25 +0000 | [diff] [blame] | 828 | UsedRegMask |= 1 << (31-i); |
| 829 | |
Chris Lattner | 402504b | 2006-04-17 21:22:06 +0000 | [diff] [blame] | 830 | // Live in and live out values already must be in the mask, so don't bother |
| 831 | // marking them. |
Chris Lattner | 84bc542 | 2007-12-31 04:13:23 +0000 | [diff] [blame] | 832 | for (MachineRegisterInfo::livein_iterator |
| 833 | I = MF->getRegInfo().livein_begin(), |
| 834 | E = MF->getRegInfo().livein_end(); I != E; ++I) { |
Chris Lattner | 402504b | 2006-04-17 21:22:06 +0000 | [diff] [blame] | 835 | unsigned RegNo = PPCRegisterInfo::getRegisterNumbering(I->first); |
| 836 | if (VRRegNo[RegNo] == I->first) // If this really is a vector reg. |
| 837 | UsedRegMask &= ~(1 << (31-RegNo)); // Doesn't need to be marked. |
| 838 | } |
Chris Lattner | 84bc542 | 2007-12-31 04:13:23 +0000 | [diff] [blame] | 839 | for (MachineRegisterInfo::liveout_iterator |
| 840 | I = MF->getRegInfo().liveout_begin(), |
| 841 | E = MF->getRegInfo().liveout_end(); I != E; ++I) { |
Chris Lattner | 402504b | 2006-04-17 21:22:06 +0000 | [diff] [blame] | 842 | unsigned RegNo = PPCRegisterInfo::getRegisterNumbering(*I); |
| 843 | if (VRRegNo[RegNo] == *I) // If this really is a vector reg. |
| 844 | UsedRegMask &= ~(1 << (31-RegNo)); // Doesn't need to be marked. |
| 845 | } |
| 846 | |
Chris Lattner | 1877ec9 | 2006-03-13 21:52:10 +0000 | [diff] [blame] | 847 | // If no registers are used, turn this into a copy. |
| 848 | if (UsedRegMask == 0) { |
Chris Lattner | f9568d8 | 2006-04-17 21:48:13 +0000 | [diff] [blame] | 849 | // Remove all VRSAVE code. |
| 850 | RemoveVRSaveCode(MI); |
| 851 | return; |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 852 | } |
| 853 | |
| 854 | unsigned SrcReg = MI->getOperand(1).getReg(); |
| 855 | unsigned DstReg = MI->getOperand(0).getReg(); |
| 856 | |
| 857 | if ((UsedRegMask & 0xFFFF) == UsedRegMask) { |
| 858 | if (DstReg != SrcReg) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 859 | BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORI), DstReg) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 860 | .addReg(SrcReg) |
| 861 | .addImm(UsedRegMask); |
| 862 | else |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 863 | BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORI), DstReg) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 864 | .addReg(SrcReg, RegState::Kill) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 865 | .addImm(UsedRegMask); |
Chris Lattner | 1877ec9 | 2006-03-13 21:52:10 +0000 | [diff] [blame] | 866 | } else if ((UsedRegMask & 0xFFFF0000) == UsedRegMask) { |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 867 | if (DstReg != SrcReg) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 868 | BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 869 | .addReg(SrcReg) |
| 870 | .addImm(UsedRegMask >> 16); |
| 871 | else |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 872 | BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 873 | .addReg(SrcReg, RegState::Kill) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 874 | .addImm(UsedRegMask >> 16); |
Chris Lattner | 1877ec9 | 2006-03-13 21:52:10 +0000 | [diff] [blame] | 875 | } else { |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 876 | if (DstReg != SrcReg) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 877 | BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 878 | .addReg(SrcReg) |
| 879 | .addImm(UsedRegMask >> 16); |
| 880 | else |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 881 | BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 882 | .addReg(SrcReg, RegState::Kill) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 883 | .addImm(UsedRegMask >> 16); |
| 884 | |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 885 | BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORI), DstReg) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 886 | .addReg(DstReg, RegState::Kill) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 887 | .addImm(UsedRegMask & 0xFFFF); |
Chris Lattner | 1877ec9 | 2006-03-13 21:52:10 +0000 | [diff] [blame] | 888 | } |
| 889 | |
| 890 | // Remove the old UPDATE_VRSAVE instruction. |
Chris Lattner | f9568d8 | 2006-04-17 21:48:13 +0000 | [diff] [blame] | 891 | MI->eraseFromParent(); |
Chris Lattner | 1877ec9 | 2006-03-13 21:52:10 +0000 | [diff] [blame] | 892 | } |
| 893 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 894 | /// determineFrameLayout - Determine the size of the frame and maximum call |
| 895 | /// frame size. |
| 896 | void PPCRegisterInfo::determineFrameLayout(MachineFunction &MF) const { |
| 897 | MachineFrameInfo *MFI = MF.getFrameInfo(); |
| 898 | |
| 899 | // Get the number of bytes to allocate from the FrameInfo |
| 900 | unsigned FrameSize = MFI->getStackSize(); |
| 901 | |
| 902 | // Get the alignments provided by the target, and the maximum alignment |
| 903 | // (if any) of the fixed frame objects. |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 904 | unsigned MaxAlign = MFI->getMaxAlignment(); |
Evan Cheng | 99403b6 | 2007-01-25 22:25:04 +0000 | [diff] [blame] | 905 | unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment(); |
| 906 | unsigned AlignMask = TargetAlign - 1; // |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 907 | |
| 908 | // If we are a leaf function, and use up to 224 bytes of stack space, |
| 909 | // don't have a frame pointer, calls, or dynamic alloca then we do not need |
| 910 | // to adjust the stack pointer (we fit in the Red Zone). |
Devang Patel | d18e31a | 2009-06-04 22:05:33 +0000 | [diff] [blame^] | 911 | bool DisableRedZone = MF.getFunction()->hasFnAttr(Attribute::NoRedZone); |
Dan Gohman | 9e79091 | 2009-01-27 19:19:28 +0000 | [diff] [blame] | 912 | if (!DisableRedZone && |
| 913 | FrameSize <= 224 && // Fits in red zone. |
Dale Johannesen | 82e4289 | 2008-03-10 22:59:46 +0000 | [diff] [blame] | 914 | !MFI->hasVarSizedObjects() && // No dynamic alloca. |
| 915 | !MFI->hasCalls() && // No calls. |
| 916 | (!ALIGN_STACK || MaxAlign <= TargetAlign)) { // No special alignment. |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 917 | // No need for frame |
| 918 | MFI->setStackSize(0); |
| 919 | return; |
| 920 | } |
| 921 | |
| 922 | // Get the maximum call frame size of all the calls. |
| 923 | unsigned maxCallFrameSize = MFI->getMaxCallFrameSize(); |
| 924 | |
| 925 | // Maximum call frame needs to be at least big enough for linkage and 8 args. |
| 926 | unsigned minCallFrameSize = |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 927 | PPCFrameInfo::getMinCallFrameSize(Subtarget.isPPC64(), |
| 928 | Subtarget.isMachoABI()); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 929 | maxCallFrameSize = std::max(maxCallFrameSize, minCallFrameSize); |
| 930 | |
| 931 | // If we have dynamic alloca then maxCallFrameSize needs to be aligned so |
| 932 | // that allocations will be aligned. |
| 933 | if (MFI->hasVarSizedObjects()) |
| 934 | maxCallFrameSize = (maxCallFrameSize + AlignMask) & ~AlignMask; |
| 935 | |
| 936 | // Update maximum call frame size. |
| 937 | MFI->setMaxCallFrameSize(maxCallFrameSize); |
| 938 | |
| 939 | // Include call frame size in total. |
| 940 | FrameSize += maxCallFrameSize; |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 941 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 942 | // Make sure the frame is aligned. |
| 943 | FrameSize = (FrameSize + AlignMask) & ~AlignMask; |
| 944 | |
| 945 | // Update frame info. |
| 946 | MFI->setStackSize(FrameSize); |
| 947 | } |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 948 | |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 949 | void |
| 950 | PPCRegisterInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF, |
| 951 | RegScavenger *RS) const { |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 952 | // Save and clear the LR state. |
| 953 | PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>(); |
| 954 | unsigned LR = getRARegister(); |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 955 | FI->setMustSaveLR(MustSaveLR(MF, LR)); |
Chris Lattner | 84bc542 | 2007-12-31 04:13:23 +0000 | [diff] [blame] | 956 | MF.getRegInfo().setPhysRegUnused(LR); |
Nicolas Geoffray | 82d4264 | 2007-03-21 16:44:14 +0000 | [diff] [blame] | 957 | |
| 958 | // Save R31 if necessary |
| 959 | int FPSI = FI->getFramePointerSaveIndex(); |
| 960 | bool IsPPC64 = Subtarget.isPPC64(); |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 961 | bool IsELF32_ABI = Subtarget.isELF32_ABI(); |
| 962 | bool IsMachoABI = Subtarget.isMachoABI(); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 963 | MachineFrameInfo *MFI = MF.getFrameInfo(); |
Nicolas Geoffray | 82d4264 | 2007-03-21 16:44:14 +0000 | [diff] [blame] | 964 | |
| 965 | // If the frame pointer save index hasn't been defined yet. |
Chris Lattner | 84bc542 | 2007-12-31 04:13:23 +0000 | [diff] [blame] | 966 | if (!FPSI && (NoFramePointerElim || MFI->hasVarSizedObjects()) && |
| 967 | IsELF32_ABI) { |
Nicolas Geoffray | 82d4264 | 2007-03-21 16:44:14 +0000 | [diff] [blame] | 968 | // Find out what the fix offset of the frame pointer save area. |
Nicolas Geoffray | ec58d9f | 2007-04-03 12:35:28 +0000 | [diff] [blame] | 969 | int FPOffset = PPCFrameInfo::getFramePointerSaveOffset(IsPPC64, |
| 970 | IsMachoABI); |
Nicolas Geoffray | 82d4264 | 2007-03-21 16:44:14 +0000 | [diff] [blame] | 971 | // Allocate the frame index for frame pointer save area. |
| 972 | FPSI = MF.getFrameInfo()->CreateFixedObject(IsPPC64? 8 : 4, FPOffset); |
| 973 | // Save the result. |
| 974 | FI->setFramePointerSaveIndex(FPSI); |
| 975 | } |
| 976 | |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 977 | // Reserve stack space to move the linkage area to in case of a tail call. |
| 978 | int TCSPDelta = 0; |
| 979 | if (PerformTailCallOpt && (TCSPDelta=FI->getTailCallSPDelta()) < 0) { |
| 980 | int AddFPOffsetAmount = IsELF32_ABI ? -4 : 0; |
| 981 | MF.getFrameInfo()->CreateFixedObject( -1 * TCSPDelta, |
| 982 | AddFPOffsetAmount + TCSPDelta); |
| 983 | } |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 984 | // Reserve a slot closest to SP or frame pointer if we have a dynalloc or |
| 985 | // a large stack, which will require scavenging a register to materialize a |
| 986 | // large offset. |
| 987 | // FIXME: this doesn't actually check stack size, so is a bit pessimistic |
| 988 | // FIXME: doesn't detect whether or not we need to spill vXX, which requires |
| 989 | // r0 for now. |
| 990 | |
Bill Wendling | 4a66e9a | 2008-03-10 22:49:16 +0000 | [diff] [blame] | 991 | if (EnableRegisterScavenging) // FIXME (64-bit): Enable. |
Bill Wendling | 880d0f6 | 2008-03-04 23:13:51 +0000 | [diff] [blame] | 992 | if (needsFP(MF) || spillsCR(MF)) { |
| 993 | const TargetRegisterClass *GPRC = &PPC::GPRCRegClass; |
| 994 | const TargetRegisterClass *G8RC = &PPC::G8RCRegClass; |
| 995 | const TargetRegisterClass *RC = IsPPC64 ? G8RC : GPRC; |
| 996 | RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(), |
Chris Lattner | 71a2cb2 | 2008-03-20 01:22:40 +0000 | [diff] [blame] | 997 | RC->getAlignment())); |
Bill Wendling | 880d0f6 | 2008-03-04 23:13:51 +0000 | [diff] [blame] | 998 | } |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 999 | } |
| 1000 | |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1001 | void |
| 1002 | PPCRegisterInfo::emitPrologue(MachineFunction &MF) const { |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1003 | MachineBasicBlock &MBB = MF.front(); // Prolog goes in entry BB |
| 1004 | MachineBasicBlock::iterator MBBI = MBB.begin(); |
| 1005 | MachineFrameInfo *MFI = MF.getFrameInfo(); |
Jim Laskey | 44c3b9f | 2007-01-26 21:22:28 +0000 | [diff] [blame] | 1006 | MachineModuleInfo *MMI = MFI->getMachineModuleInfo(); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1007 | DebugLoc dl = DebugLoc::getUnknownLoc(); |
Dale Johannesen | e004062 | 2008-04-02 17:04:45 +0000 | [diff] [blame] | 1008 | bool needsFrameMoves = (MMI && MMI->hasDebugInfo()) || |
Dale Johannesen | 4e1b794 | 2008-04-08 00:10:24 +0000 | [diff] [blame] | 1009 | !MF.getFunction()->doesNotThrow() || |
Dale Johannesen | 3541af7 | 2008-04-14 17:54:17 +0000 | [diff] [blame] | 1010 | UnwindTablesMandatory; |
Chris Lattner | 4f91a4c | 2006-04-03 22:03:29 +0000 | [diff] [blame] | 1011 | |
Jim Laskey | 072200c | 2007-01-29 18:51:14 +0000 | [diff] [blame] | 1012 | // Prepare for frame info. |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1013 | unsigned FrameLabelId = 0; |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1014 | |
Chris Lattner | 4f91a4c | 2006-04-03 22:03:29 +0000 | [diff] [blame] | 1015 | // Scan the prolog, looking for an UPDATE_VRSAVE instruction. If we find it, |
| 1016 | // process it. |
Chris Lattner | 8aa777d | 2006-03-16 21:31:45 +0000 | [diff] [blame] | 1017 | for (unsigned i = 0; MBBI != MBB.end(); ++i, ++MBBI) { |
Chris Lattner | 1877ec9 | 2006-03-13 21:52:10 +0000 | [diff] [blame] | 1018 | if (MBBI->getOpcode() == PPC::UPDATE_VRSAVE) { |
Evan Cheng | 6c087e5 | 2007-04-25 22:13:27 +0000 | [diff] [blame] | 1019 | HandleVRSaveUpdate(MBBI, TII); |
Chris Lattner | 1877ec9 | 2006-03-13 21:52:10 +0000 | [diff] [blame] | 1020 | break; |
| 1021 | } |
| 1022 | } |
| 1023 | |
| 1024 | // Move MBBI back to the beginning of the function. |
| 1025 | MBBI = MBB.begin(); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1026 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1027 | // Work out frame sizes. |
| 1028 | determineFrameLayout(MF); |
| 1029 | unsigned FrameSize = MFI->getStackSize(); |
Nate Begeman | ae232e7 | 2005-11-06 09:00:38 +0000 | [diff] [blame] | 1030 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1031 | int NegFrameSize = -FrameSize; |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1032 | |
| 1033 | // Get processor type. |
| 1034 | bool IsPPC64 = Subtarget.isPPC64(); |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 1035 | // Get operating system |
| 1036 | bool IsMachoABI = Subtarget.isMachoABI(); |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1037 | // Check if the link register (LR) must be saved. |
| 1038 | PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>(); |
| 1039 | bool MustSaveLR = FI->mustSaveLR(); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1040 | // Do we have a frame pointer for this function? |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 1041 | bool HasFP = hasFP(MF) && FrameSize; |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1042 | |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 1043 | int LROffset = PPCFrameInfo::getReturnSaveOffset(IsPPC64, IsMachoABI); |
| 1044 | int FPOffset = PPCFrameInfo::getFramePointerSaveOffset(IsPPC64, IsMachoABI); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1045 | |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1046 | if (IsPPC64) { |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1047 | if (MustSaveLR) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1048 | BuildMI(MBB, MBBI, dl, TII.get(PPC::MFLR8), PPC::X0); |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1049 | |
| 1050 | if (HasFP) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1051 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STD)) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1052 | .addReg(PPC::X31) |
| 1053 | .addImm(FPOffset/4) |
| 1054 | .addReg(PPC::X1); |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1055 | |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1056 | if (MustSaveLR) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1057 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STD)) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1058 | .addReg(PPC::X0) |
| 1059 | .addImm(LROffset / 4) |
| 1060 | .addReg(PPC::X1); |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1061 | } else { |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1062 | if (MustSaveLR) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1063 | BuildMI(MBB, MBBI, dl, TII.get(PPC::MFLR), PPC::R0); |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1064 | |
| 1065 | if (HasFP) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1066 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STW)) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1067 | .addReg(PPC::R31) |
| 1068 | .addImm(FPOffset) |
| 1069 | .addReg(PPC::R1); |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1070 | |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1071 | if (MustSaveLR) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1072 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STW)) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1073 | .addReg(PPC::R0) |
| 1074 | .addImm(LROffset) |
| 1075 | .addReg(PPC::R1); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1076 | } |
| 1077 | |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 1078 | // Skip if a leaf routine. |
| 1079 | if (!FrameSize) return; |
| 1080 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1081 | // Get stack alignments. |
Nate Begeman | ae232e7 | 2005-11-06 09:00:38 +0000 | [diff] [blame] | 1082 | unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment(); |
| 1083 | unsigned MaxAlign = MFI->getMaxAlignment(); |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1084 | |
Dale Johannesen | e004062 | 2008-04-02 17:04:45 +0000 | [diff] [blame] | 1085 | if (needsFrameMoves) { |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1086 | // Mark effective beginning of when frame pointer becomes valid. |
Jim Laskey | 44c3b9f | 2007-01-26 21:22:28 +0000 | [diff] [blame] | 1087 | FrameLabelId = MMI->NextLabelID(); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1088 | BuildMI(MBB, MBBI, dl, TII.get(PPC::DBG_LABEL)).addImm(FrameLabelId); |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1089 | } |
| 1090 | |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1091 | // Adjust stack pointer: r1 += NegFrameSize. |
Nate Begeman | 030514c | 2006-04-11 19:29:21 +0000 | [diff] [blame] | 1092 | // If there is a preferred stack alignment, align R1 now |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1093 | if (!IsPPC64) { |
Chris Lattner | a94a203 | 2006-11-11 19:05:28 +0000 | [diff] [blame] | 1094 | // PPC32. |
Dale Johannesen | 82e4289 | 2008-03-10 22:59:46 +0000 | [diff] [blame] | 1095 | if (ALIGN_STACK && MaxAlign > TargetAlign) { |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1096 | assert(isPowerOf2_32(MaxAlign)&&isInt16(MaxAlign)&&"Invalid alignment!"); |
| 1097 | assert(isInt16(NegFrameSize) && "Unhandled stack size and alignment!"); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1098 | |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1099 | BuildMI(MBB, MBBI, dl, TII.get(PPC::RLWINM), PPC::R0) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1100 | .addReg(PPC::R1) |
| 1101 | .addImm(0) |
| 1102 | .addImm(32 - Log2_32(MaxAlign)) |
| 1103 | .addImm(31); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1104 | BuildMI(MBB, MBBI, dl, TII.get(PPC::SUBFIC) ,PPC::R0) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 1105 | .addReg(PPC::R0, RegState::Kill) |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1106 | .addImm(NegFrameSize); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1107 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STWUX)) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1108 | .addReg(PPC::R1) |
| 1109 | .addReg(PPC::R1) |
| 1110 | .addReg(PPC::R0); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1111 | } else if (isInt16(NegFrameSize)) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1112 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STWU), PPC::R1) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1113 | .addReg(PPC::R1) |
| 1114 | .addImm(NegFrameSize) |
| 1115 | .addReg(PPC::R1); |
Chris Lattner | a94a203 | 2006-11-11 19:05:28 +0000 | [diff] [blame] | 1116 | } else { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1117 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LIS), PPC::R0) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1118 | .addImm(NegFrameSize >> 16); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1119 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ORI), PPC::R0) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 1120 | .addReg(PPC::R0, RegState::Kill) |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1121 | .addImm(NegFrameSize & 0xFFFF); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1122 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STWUX)) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1123 | .addReg(PPC::R1) |
| 1124 | .addReg(PPC::R1) |
Chris Lattner | a94a203 | 2006-11-11 19:05:28 +0000 | [diff] [blame] | 1125 | .addReg(PPC::R0); |
| 1126 | } |
| 1127 | } else { // PPC64. |
Dale Johannesen | 82e4289 | 2008-03-10 22:59:46 +0000 | [diff] [blame] | 1128 | if (ALIGN_STACK && MaxAlign > TargetAlign) { |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1129 | assert(isPowerOf2_32(MaxAlign)&&isInt16(MaxAlign)&&"Invalid alignment!"); |
| 1130 | assert(isInt16(NegFrameSize) && "Unhandled stack size and alignment!"); |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1131 | |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1132 | BuildMI(MBB, MBBI, dl, TII.get(PPC::RLDICL), PPC::X0) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1133 | .addReg(PPC::X1) |
| 1134 | .addImm(0) |
| 1135 | .addImm(64 - Log2_32(MaxAlign)); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1136 | BuildMI(MBB, MBBI, dl, TII.get(PPC::SUBFIC8), PPC::X0) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1137 | .addReg(PPC::X0) |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1138 | .addImm(NegFrameSize); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1139 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STDUX)) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1140 | .addReg(PPC::X1) |
| 1141 | .addReg(PPC::X1) |
| 1142 | .addReg(PPC::X0); |
Jim Laskey | 2ff5cdb | 2006-11-17 16:09:31 +0000 | [diff] [blame] | 1143 | } else if (isInt16(NegFrameSize)) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1144 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STDU), PPC::X1) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1145 | .addReg(PPC::X1) |
| 1146 | .addImm(NegFrameSize / 4) |
| 1147 | .addReg(PPC::X1); |
Chris Lattner | a94a203 | 2006-11-11 19:05:28 +0000 | [diff] [blame] | 1148 | } else { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1149 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LIS8), PPC::X0) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1150 | .addImm(NegFrameSize >> 16); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1151 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ORI8), PPC::X0) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 1152 | .addReg(PPC::X0, RegState::Kill) |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1153 | .addImm(NegFrameSize & 0xFFFF); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1154 | BuildMI(MBB, MBBI, dl, TII.get(PPC::STDUX)) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1155 | .addReg(PPC::X1) |
| 1156 | .addReg(PPC::X1) |
Chris Lattner | a94a203 | 2006-11-11 19:05:28 +0000 | [diff] [blame] | 1157 | .addReg(PPC::X0); |
| 1158 | } |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1159 | } |
Nate Begeman | ae232e7 | 2005-11-06 09:00:38 +0000 | [diff] [blame] | 1160 | |
Dale Johannesen | e004062 | 2008-04-02 17:04:45 +0000 | [diff] [blame] | 1161 | if (needsFrameMoves) { |
Jim Laskey | 44c3b9f | 2007-01-26 21:22:28 +0000 | [diff] [blame] | 1162 | std::vector<MachineMove> &Moves = MMI->getFrameMoves(); |
Jim Laskey | 4188699 | 2006-04-07 16:34:46 +0000 | [diff] [blame] | 1163 | |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1164 | if (NegFrameSize) { |
| 1165 | // Show update of SP. |
| 1166 | MachineLocation SPDst(MachineLocation::VirtualFP); |
| 1167 | MachineLocation SPSrc(MachineLocation::VirtualFP, NegFrameSize); |
| 1168 | Moves.push_back(MachineMove(FrameLabelId, SPDst, SPSrc)); |
| 1169 | } else { |
| 1170 | MachineLocation SP(IsPPC64 ? PPC::X31 : PPC::R31); |
| 1171 | Moves.push_back(MachineMove(FrameLabelId, SP, SP)); |
| 1172 | } |
Jim Laskey | 4c2c903 | 2006-08-25 19:40:59 +0000 | [diff] [blame] | 1173 | |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1174 | if (HasFP) { |
| 1175 | MachineLocation FPDst(MachineLocation::VirtualFP, FPOffset); |
| 1176 | MachineLocation FPSrc(IsPPC64 ? PPC::X31 : PPC::R31); |
| 1177 | Moves.push_back(MachineMove(FrameLabelId, FPDst, FPSrc)); |
| 1178 | } |
Jim Laskey | ce50a16 | 2006-08-29 16:24:26 +0000 | [diff] [blame] | 1179 | |
| 1180 | // Add callee saved registers to move list. |
| 1181 | const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo(); |
| 1182 | for (unsigned I = 0, E = CSI.size(); I != E; ++I) { |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1183 | int Offset = MFI->getObjectOffset(CSI[I].getFrameIdx()); |
| 1184 | unsigned Reg = CSI[I].getReg(); |
Dale Johannesen | b384ab9 | 2008-10-29 18:26:45 +0000 | [diff] [blame] | 1185 | if (Reg == PPC::LR || Reg == PPC::LR8 || Reg == PPC::RM) continue; |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1186 | MachineLocation CSDst(MachineLocation::VirtualFP, Offset); |
| 1187 | MachineLocation CSSrc(Reg); |
| 1188 | Moves.push_back(MachineMove(FrameLabelId, CSDst, CSSrc)); |
Jim Laskey | ce50a16 | 2006-08-29 16:24:26 +0000 | [diff] [blame] | 1189 | } |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1190 | |
Jim Laskey | b82313f | 2007-02-01 16:31:34 +0000 | [diff] [blame] | 1191 | MachineLocation LRDst(MachineLocation::VirtualFP, LROffset); |
| 1192 | MachineLocation LRSrc(IsPPC64 ? PPC::LR8 : PPC::LR); |
| 1193 | Moves.push_back(MachineMove(FrameLabelId, LRDst, LRSrc)); |
| 1194 | |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1195 | // Mark effective beginning of when frame pointer is ready. |
Jim Laskey | 44c3b9f | 2007-01-26 21:22:28 +0000 | [diff] [blame] | 1196 | unsigned ReadyLabelId = MMI->NextLabelID(); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1197 | BuildMI(MBB, MBBI, dl, TII.get(PPC::DBG_LABEL)).addImm(ReadyLabelId); |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1198 | |
| 1199 | MachineLocation FPDst(HasFP ? (IsPPC64 ? PPC::X31 : PPC::R31) : |
| 1200 | (IsPPC64 ? PPC::X1 : PPC::R1)); |
| 1201 | MachineLocation FPSrc(MachineLocation::VirtualFP); |
| 1202 | Moves.push_back(MachineMove(ReadyLabelId, FPDst, FPSrc)); |
Jim Laskey | 4188699 | 2006-04-07 16:34:46 +0000 | [diff] [blame] | 1203 | } |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1204 | |
| 1205 | // If there is a frame pointer, copy R1 into R31 |
Chris Lattner | 4f91a4c | 2006-04-03 22:03:29 +0000 | [diff] [blame] | 1206 | if (HasFP) { |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1207 | if (!IsPPC64) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1208 | BuildMI(MBB, MBBI, dl, TII.get(PPC::OR), PPC::R31) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1209 | .addReg(PPC::R1) |
Evan Cheng | c0f64ff | 2006-11-27 23:37:22 +0000 | [diff] [blame] | 1210 | .addReg(PPC::R1); |
Chris Lattner | a94a203 | 2006-11-11 19:05:28 +0000 | [diff] [blame] | 1211 | } else { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1212 | BuildMI(MBB, MBBI, dl, TII.get(PPC::OR8), PPC::X31) |
Bill Wendling | 7194aaf | 2008-03-03 22:19:16 +0000 | [diff] [blame] | 1213 | .addReg(PPC::X1) |
Evan Cheng | c0f64ff | 2006-11-27 23:37:22 +0000 | [diff] [blame] | 1214 | .addReg(PPC::X1); |
Chris Lattner | a94a203 | 2006-11-11 19:05:28 +0000 | [diff] [blame] | 1215 | } |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1216 | } |
| 1217 | } |
| 1218 | |
Nate Begeman | 21e463b | 2005-10-16 05:39:50 +0000 | [diff] [blame] | 1219 | void PPCRegisterInfo::emitEpilogue(MachineFunction &MF, |
| 1220 | MachineBasicBlock &MBB) const { |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1221 | MachineBasicBlock::iterator MBBI = prior(MBB.end()); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1222 | unsigned RetOpcode = MBBI->getOpcode(); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1223 | DebugLoc dl = DebugLoc::getUnknownLoc(); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1224 | |
| 1225 | assert( (RetOpcode == PPC::BLR || |
| 1226 | RetOpcode == PPC::TCRETURNri || |
| 1227 | RetOpcode == PPC::TCRETURNdi || |
| 1228 | RetOpcode == PPC::TCRETURNai || |
| 1229 | RetOpcode == PPC::TCRETURNri8 || |
| 1230 | RetOpcode == PPC::TCRETURNdi8 || |
| 1231 | RetOpcode == PPC::TCRETURNai8) && |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1232 | "Can only insert epilog into returning blocks"); |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 1233 | |
Nate Begeman | 030514c | 2006-04-11 19:29:21 +0000 | [diff] [blame] | 1234 | // Get alignment info so we know how to restore r1 |
| 1235 | const MachineFrameInfo *MFI = MF.getFrameInfo(); |
| 1236 | unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment(); |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1237 | unsigned MaxAlign = MFI->getMaxAlignment(); |
Nate Begeman | 030514c | 2006-04-11 19:29:21 +0000 | [diff] [blame] | 1238 | |
Chris Lattner | 64da172 | 2006-01-11 23:03:54 +0000 | [diff] [blame] | 1239 | // Get the number of bytes allocated from the FrameInfo. |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1240 | int FrameSize = MFI->getStackSize(); |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1241 | |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1242 | // Get processor type. |
| 1243 | bool IsPPC64 = Subtarget.isPPC64(); |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 1244 | // Get operating system |
| 1245 | bool IsMachoABI = Subtarget.isMachoABI(); |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1246 | // Check if the link register (LR) has been saved. |
| 1247 | PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>(); |
| 1248 | bool MustSaveLR = FI->mustSaveLR(); |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1249 | // Do we have a frame pointer for this function? |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 1250 | bool HasFP = hasFP(MF) && FrameSize; |
Chris Lattner | 9f0bc65 | 2007-02-25 05:34:32 +0000 | [diff] [blame] | 1251 | |
| 1252 | int LROffset = PPCFrameInfo::getReturnSaveOffset(IsPPC64, IsMachoABI); |
| 1253 | int FPOffset = PPCFrameInfo::getFramePointerSaveOffset(IsPPC64, IsMachoABI); |
| 1254 | |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1255 | bool UsesTCRet = RetOpcode == PPC::TCRETURNri || |
| 1256 | RetOpcode == PPC::TCRETURNdi || |
| 1257 | RetOpcode == PPC::TCRETURNai || |
| 1258 | RetOpcode == PPC::TCRETURNri8 || |
| 1259 | RetOpcode == PPC::TCRETURNdi8 || |
| 1260 | RetOpcode == PPC::TCRETURNai8; |
| 1261 | |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1262 | if (UsesTCRet) { |
| 1263 | int MaxTCRetDelta = FI->getTailCallSPDelta(); |
| 1264 | MachineOperand &StackAdjust = MBBI->getOperand(1); |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 1265 | assert(StackAdjust.isImm() && "Expecting immediate value."); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1266 | // Adjust stack pointer. |
| 1267 | int StackAdj = StackAdjust.getImm(); |
| 1268 | int Delta = StackAdj - MaxTCRetDelta; |
| 1269 | assert((Delta >= 0) && "Delta must be positive"); |
| 1270 | if (MaxTCRetDelta>0) |
| 1271 | FrameSize += (StackAdj +Delta); |
| 1272 | else |
| 1273 | FrameSize += StackAdj; |
| 1274 | } |
| 1275 | |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 1276 | if (FrameSize) { |
| 1277 | // The loaded (or persistent) stack pointer value is offset by the 'stwu' |
| 1278 | // on entry to the function. Add this offset back now. |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1279 | if (!IsPPC64) { |
| 1280 | // If this function contained a fastcc call and PerformTailCallOpt is |
| 1281 | // enabled (=> hasFastCall()==true) the fastcc call might contain a tail |
| 1282 | // call which invalidates the stack pointer value in SP(0). So we use the |
| 1283 | // value of R31 in this case. |
| 1284 | if (FI->hasFastCall() && isInt16(FrameSize)) { |
| 1285 | assert(hasFP(MF) && "Expecting a valid the frame pointer."); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1286 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ADDI), PPC::R1) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1287 | .addReg(PPC::R31).addImm(FrameSize); |
| 1288 | } else if(FI->hasFastCall()) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1289 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LIS), PPC::R0) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1290 | .addImm(FrameSize >> 16); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1291 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ORI), PPC::R0) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 1292 | .addReg(PPC::R0, RegState::Kill) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1293 | .addImm(FrameSize & 0xFFFF); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1294 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ADD4)) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1295 | .addReg(PPC::R1) |
| 1296 | .addReg(PPC::R31) |
| 1297 | .addReg(PPC::R0); |
| 1298 | } else if (isInt16(FrameSize) && |
| 1299 | (!ALIGN_STACK || TargetAlign >= MaxAlign) && |
| 1300 | !MFI->hasVarSizedObjects()) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1301 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ADDI), PPC::R1) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1302 | .addReg(PPC::R1).addImm(FrameSize); |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 1303 | } else { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1304 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LWZ),PPC::R1) |
| 1305 | .addImm(0).addReg(PPC::R1); |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 1306 | } |
Chris Lattner | 64da172 | 2006-01-11 23:03:54 +0000 | [diff] [blame] | 1307 | } else { |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1308 | if (FI->hasFastCall() && isInt16(FrameSize)) { |
| 1309 | assert(hasFP(MF) && "Expecting a valid the frame pointer."); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1310 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ADDI8), PPC::X1) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1311 | .addReg(PPC::X31).addImm(FrameSize); |
| 1312 | } else if(FI->hasFastCall()) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1313 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LIS8), PPC::X0) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1314 | .addImm(FrameSize >> 16); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1315 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ORI8), PPC::X0) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 1316 | .addReg(PPC::X0, RegState::Kill) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1317 | .addImm(FrameSize & 0xFFFF); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1318 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ADD8)) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1319 | .addReg(PPC::X1) |
| 1320 | .addReg(PPC::X31) |
| 1321 | .addReg(PPC::X0); |
| 1322 | } else if (isInt16(FrameSize) && TargetAlign >= MaxAlign && |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 1323 | !MFI->hasVarSizedObjects()) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1324 | BuildMI(MBB, MBBI, dl, TII.get(PPC::ADDI8), PPC::X1) |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 1325 | .addReg(PPC::X1).addImm(FrameSize); |
| 1326 | } else { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1327 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LD), PPC::X1) |
| 1328 | .addImm(0).addReg(PPC::X1); |
Jim Laskey | d313a9b | 2007-02-27 11:55:45 +0000 | [diff] [blame] | 1329 | } |
Jim Laskey | 2f616bf | 2006-11-16 22:43:37 +0000 | [diff] [blame] | 1330 | } |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1331 | } |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1332 | |
| 1333 | if (IsPPC64) { |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1334 | if (MustSaveLR) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1335 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LD), PPC::X0) |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1336 | .addImm(LROffset/4).addReg(PPC::X1); |
| 1337 | |
| 1338 | if (HasFP) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1339 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LD), PPC::X31) |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1340 | .addImm(FPOffset/4).addReg(PPC::X1); |
| 1341 | |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1342 | if (MustSaveLR) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1343 | BuildMI(MBB, MBBI, dl, TII.get(PPC::MTLR8)).addReg(PPC::X0); |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1344 | } else { |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1345 | if (MustSaveLR) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1346 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LWZ), PPC::R0) |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1347 | .addImm(LROffset).addReg(PPC::R1); |
| 1348 | |
| 1349 | if (HasFP) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1350 | BuildMI(MBB, MBBI, dl, TII.get(PPC::LWZ), PPC::R31) |
Jim Laskey | 51fe9d9 | 2006-12-06 17:42:06 +0000 | [diff] [blame] | 1351 | .addImm(FPOffset).addReg(PPC::R1); |
| 1352 | |
Dale Johannesen | c12e581 | 2008-10-24 21:24:23 +0000 | [diff] [blame] | 1353 | if (MustSaveLR) |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1354 | BuildMI(MBB, MBBI, dl, TII.get(PPC::MTLR)).addReg(PPC::R0); |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1355 | } |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1356 | |
| 1357 | // Callee pop calling convention. Pop parameter/linkage area. Used for tail |
| 1358 | // call optimization |
| 1359 | if (PerformTailCallOpt && RetOpcode == PPC::BLR && |
| 1360 | MF.getFunction()->getCallingConv() == CallingConv::Fast) { |
| 1361 | PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>(); |
| 1362 | unsigned CallerAllocatedAmt = FI->getMinReservedArea(); |
| 1363 | unsigned StackReg = IsPPC64 ? PPC::X1 : PPC::R1; |
| 1364 | unsigned FPReg = IsPPC64 ? PPC::X31 : PPC::R31; |
| 1365 | unsigned TmpReg = IsPPC64 ? PPC::X0 : PPC::R0; |
| 1366 | unsigned ADDIInstr = IsPPC64 ? PPC::ADDI8 : PPC::ADDI; |
| 1367 | unsigned ADDInstr = IsPPC64 ? PPC::ADD8 : PPC::ADD4; |
| 1368 | unsigned LISInstr = IsPPC64 ? PPC::LIS8 : PPC::LIS; |
| 1369 | unsigned ORIInstr = IsPPC64 ? PPC::ORI8 : PPC::ORI; |
| 1370 | |
| 1371 | if (CallerAllocatedAmt && isInt16(CallerAllocatedAmt)) { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1372 | BuildMI(MBB, MBBI, dl, TII.get(ADDIInstr), StackReg) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1373 | .addReg(StackReg).addImm(CallerAllocatedAmt); |
| 1374 | } else { |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1375 | BuildMI(MBB, MBBI, dl, TII.get(LISInstr), TmpReg) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1376 | .addImm(CallerAllocatedAmt >> 16); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1377 | BuildMI(MBB, MBBI, dl, TII.get(ORIInstr), TmpReg) |
Bill Wendling | 587daed | 2009-05-13 21:33:08 +0000 | [diff] [blame] | 1378 | .addReg(TmpReg, RegState::Kill) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1379 | .addImm(CallerAllocatedAmt & 0xFFFF); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1380 | BuildMI(MBB, MBBI, dl, TII.get(ADDInstr)) |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1381 | .addReg(StackReg) |
| 1382 | .addReg(FPReg) |
| 1383 | .addReg(TmpReg); |
| 1384 | } |
| 1385 | } else if (RetOpcode == PPC::TCRETURNdi) { |
| 1386 | MBBI = prior(MBB.end()); |
| 1387 | MachineOperand &JumpTarget = MBBI->getOperand(0); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1388 | BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILB)). |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1389 | addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset()); |
| 1390 | } else if (RetOpcode == PPC::TCRETURNri) { |
| 1391 | MBBI = prior(MBB.end()); |
Chris Lattner | 022a27e | 2009-03-26 05:25:59 +0000 | [diff] [blame] | 1392 | assert(MBBI->getOperand(0).isReg() && "Expecting register operand."); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1393 | BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBCTR)); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1394 | } else if (RetOpcode == PPC::TCRETURNai) { |
| 1395 | MBBI = prior(MBB.end()); |
| 1396 | MachineOperand &JumpTarget = MBBI->getOperand(0); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1397 | BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBA)).addImm(JumpTarget.getImm()); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1398 | } else if (RetOpcode == PPC::TCRETURNdi8) { |
| 1399 | MBBI = prior(MBB.end()); |
| 1400 | MachineOperand &JumpTarget = MBBI->getOperand(0); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1401 | BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILB8)). |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1402 | addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset()); |
| 1403 | } else if (RetOpcode == PPC::TCRETURNri8) { |
| 1404 | MBBI = prior(MBB.end()); |
Chris Lattner | 022a27e | 2009-03-26 05:25:59 +0000 | [diff] [blame] | 1405 | assert(MBBI->getOperand(0).isReg() && "Expecting register operand."); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1406 | BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBCTR8)); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1407 | } else if (RetOpcode == PPC::TCRETURNai8) { |
| 1408 | MBBI = prior(MBB.end()); |
| 1409 | MachineOperand &JumpTarget = MBBI->getOperand(0); |
Dale Johannesen | 536a2f1 | 2009-02-13 02:27:39 +0000 | [diff] [blame] | 1410 | BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBA8)).addImm(JumpTarget.getImm()); |
Arnold Schwaighofer | 30e62c0 | 2008-04-30 09:16:33 +0000 | [diff] [blame] | 1411 | } |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1412 | } |
| 1413 | |
Jim Laskey | 4188699 | 2006-04-07 16:34:46 +0000 | [diff] [blame] | 1414 | unsigned PPCRegisterInfo::getRARegister() const { |
Chris Lattner | 6a5339b | 2006-11-14 18:44:47 +0000 | [diff] [blame] | 1415 | return !Subtarget.isPPC64() ? PPC::LR : PPC::LR8; |
Jim Laskey | 4188699 | 2006-04-07 16:34:46 +0000 | [diff] [blame] | 1416 | } |
| 1417 | |
Jim Laskey | a997918 | 2006-03-28 13:48:33 +0000 | [diff] [blame] | 1418 | unsigned PPCRegisterInfo::getFrameRegister(MachineFunction &MF) const { |
Chris Lattner | a94a203 | 2006-11-11 19:05:28 +0000 | [diff] [blame] | 1419 | if (!Subtarget.isPPC64()) |
| 1420 | return hasFP(MF) ? PPC::R31 : PPC::R1; |
| 1421 | else |
| 1422 | return hasFP(MF) ? PPC::X31 : PPC::X1; |
Jim Laskey | 4188699 | 2006-04-07 16:34:46 +0000 | [diff] [blame] | 1423 | } |
| 1424 | |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1425 | void PPCRegisterInfo::getInitialFrameState(std::vector<MachineMove> &Moves) |
Jim Laskey | 4188699 | 2006-04-07 16:34:46 +0000 | [diff] [blame] | 1426 | const { |
Jim Laskey | 4c2c903 | 2006-08-25 19:40:59 +0000 | [diff] [blame] | 1427 | // Initial state of the frame pointer is R1. |
Jim Laskey | 4188699 | 2006-04-07 16:34:46 +0000 | [diff] [blame] | 1428 | MachineLocation Dst(MachineLocation::VirtualFP); |
| 1429 | MachineLocation Src(PPC::R1, 0); |
Jim Laskey | 5e73d5b | 2007-01-24 18:45:13 +0000 | [diff] [blame] | 1430 | Moves.push_back(MachineMove(0, Dst, Src)); |
Jim Laskey | f1d78e8 | 2006-03-23 18:12:57 +0000 | [diff] [blame] | 1431 | } |
| 1432 | |
Jim Laskey | 62819f3 | 2007-02-21 22:54:50 +0000 | [diff] [blame] | 1433 | unsigned PPCRegisterInfo::getEHExceptionRegister() const { |
| 1434 | return !Subtarget.isPPC64() ? PPC::R3 : PPC::X3; |
| 1435 | } |
| 1436 | |
| 1437 | unsigned PPCRegisterInfo::getEHHandlerRegister() const { |
| 1438 | return !Subtarget.isPPC64() ? PPC::R4 : PPC::X4; |
| 1439 | } |
| 1440 | |
Dale Johannesen | b97aec6 | 2007-11-13 19:13:01 +0000 | [diff] [blame] | 1441 | int PPCRegisterInfo::getDwarfRegNum(unsigned RegNum, bool isEH) const { |
Anton Korobeynikov | 3809fbe | 2007-11-12 23:36:13 +0000 | [diff] [blame] | 1442 | // FIXME: Most probably dwarf numbers differs for Linux and Darwin |
| 1443 | return PPCGenRegisterInfo::getDwarfRegNumFull(RegNum, 0); |
Anton Korobeynikov | f191c80 | 2007-11-11 19:50:10 +0000 | [diff] [blame] | 1444 | } |
| 1445 | |
Chris Lattner | 4c7b43b | 2005-10-14 23:37:35 +0000 | [diff] [blame] | 1446 | #include "PPCGenRegisterInfo.inc" |
Misha Brukman | f2ccb77 | 2004-08-17 04:55:41 +0000 | [diff] [blame] | 1447 | |