[PATCH] FastISel fixes with FeatureVSX enabled

[seurer]

Summary

Test case and FastISel fixes with FeatureVSX enabled

There are a number of test cases that fail if FeatureVSX is turned on.

Many of them use options that aren't compatible with VSX (like -m32 or darwin
targets). I just disabled vsx (via -mattr=-vsx) for these.

The rest are looking for specific instructions that are not generated with
FeatureVSX enabled. I added -mattr=-vsx to the existing test checks for these
and then added new checks specific to VSX to look for the VSX instructions that
are generated instead.

The FastISel code cannot handle VSX registers and various assertion checks
will fail if one is encountered when it runs. I changed all the places in
FastISEL that allocate registers to check for VSX registers and return false
if one is found so that the regular code gen can handle it.

[mcrosier]

Added Daniel and Reed as reviews.

[echristo]

Wrong reviewers. :)

This is PPC you want one of these.

[echristo]

This should probably all be handled via the isTypeLegal machinery rather than this cut and paste.

Thanks!

-eric

[hfinkel]

Thanks for working on this!

Regarding approach, instead of disabling parts of FastISel when VSX is enabled, why don't we disable VSX when FastISel would be used? For example, what if in PPCSubtarget::initSubtargetFeatures we added something like this after the call to ParseSubtargetFeatures:

if (OptLevel == CodeGenOpt::None) or even better if possible (TM.Options.EnableFastISel)
  HasVSX = false;

(we already do something similar for little-Endian mode currently). Then we just need to add an assert in the FastISel implementation that VSX is not enabled.

As a general note, please upload full-context diffs in the future (see http://llvm.org/docs/Phabricator.html for instructions).

[seurer]

In D5362#12, @hfinkel wrote:

Thanks for working on this!

Regarding approach, instead of disabling parts of FastISel when VSX is enabled, why don't we disable VSX when FastISel would be used? For example, what if in PPCSubtarget::initSubtargetFeatures we added something like this after the call to ParseSubtargetFeatures:

if (OptLevel == CodeGenOpt::None) or even better if possible (TM.Options.EnableFastISel)
  HasVSX = false;

(we already do something similar for little-Endian mode currently). Then we just need to add an assert in the FastISel implementation that VSX is not enabled.

How about changing getRegForValue to return 0 if it ends up with a VSX register. All the uses of getRegForValue already check for a 0 return value. That moves the code to just one spot and there are already multiple checks there for things that FastISel can't handle.

As a general note, please upload full-context diffs in the future (see http://llvm.org/docs/Phabricator.html for instructions).

Will do.

[seurer]

New IsTypeLegal function added to FastISel
Overrides for IsTypeLegal added to PPCFastIsel
Some additional test case updates, mostly with option changes

[wschmidt]

Hi Bill,

This looks much better with the checking all in one place -- thanks for doing that! I don't see any problems with the patch from my end -- will defer to Hal and Eric whether their concerns are all handled.

I see we will have an opportunity to improve code gen for mcm-12.ll. Using the indexed-form VSX instruction allows use of more registers but means we need an extra addi in this sequence over just using lfd. But that's for the future...

[hfinkel]

/home/seurer/llvm/llvm-test/include/llvm/CodeGen/FastISel.h

486 ↗

(On Diff #14458)

Do other targets break if you make this call their two-argument isTypeLegal with a throw-away VT argument?

I'd rather do this in a way that targets don't need to provide two very-similar overrides and keep them in sync if possible.

/home/seurer/llvm/llvm-test/lib/Target/PowerPC/PPCFastISel.cpp

264 ↗

(On Diff #14458)

Not sure about f128 (it is not a legal type, and I assume the base class will take care of this), but if ppcf128 should be here, please add it.

[seurer]

Added const to isTypeLegal functions
Removed comment about f128 types

[seurer]

Removed default FeatureVSX in PPC.td
Two changes in FastISel.cpp to avoid svn code merge problems

After discussing this with Bill Schmidt we decided to not turn on FeatureVSX by default. There are some recent code updates elsewhere (unrelated to this) which cause register issues when FeatureVSX is turned on.

[echristo]

Out of curiosity, why not this patch?

dzur:~/sources/llvm> git diff
diff --git a/lib/Target/PowerPC/PPCFastISel.cpp
b/lib/Target/PowerPC/PPCFastISel.cpp
index 99aa4ea..b36c5c8 100644

• a/lib/Target/PowerPC/PPCFastISel.cpp

+++ b/lib/Target/PowerPC/PPCFastISel.cpp
@@ -2284,7 +2284,7 @@ namespace llvm {

// Only available on 64-bit ELF for now.
const PPCSubtarget *Subtarget = &TM.getSubtarget<PPCSubtarget>();

• if (Subtarget->isPPC64() && Subtarget->isSVR4ABI())

+ if (Subtarget->isPPC64() && Subtarget->isSVR4ABI() && !Subtarget->hasVSX())

  return new PPCFastISel(FuncInfo, LibInfo);

return nullptr;

[seurer]

Changes to fma.ll to fix merging

[echristo]

Not such a huge fan of the new EVT code. This is what the Type *, MVT
& code is for. What's giving you an EVT where you're not checking for
simple?

I.e. I see no reason this shouldn't work like:

bool PPCFastISel::isTypeLegal(Type *Ty, MVT &VT) {

EVT E = TLI.getValueType(Ty, true);

// Only handle simple types.
if (E == MVT::Other || !E.isSimple())
  return false;
VT = E.getSimpleVT();

if (VT == MVT::f64 || VT.isVector())
  return false;

return TLI.isTypeLegal(VT);

}

(though do we handle f64 or vectors if we don't have VSX? Do we need
both checks? etc)

-eric

[echristo]

OK, after some more looking I see where you're going with this. I
think the various bits can be unified under the isTypeLegal I brought
up before and making that virtual with the simple check it looks like
all of them check for MVT::isSimple() first.. You might need to pull
out the Other check though.

Few comments on the patch otherwise:

+++ /home/seurer/llvm/llvm-test/test/CodeGen/Generic/select-cc.ll
@@ -1,4 +1,4 @@
-; RUN: llc < %s
+; RUN: llc -mattr=-vsx < %s

This is a generic codegen test. You can't change it this way.

+++ /home/seurer/llvm/llvm-test/test/CodeGen/PowerPC/2007-09-08-unaligned.ll
@@ -1,7 +1,11 @@
-; RUN: llc < %s | grep stfd | count 3
-; RUN: llc < %s | grep stfs | count 1
-; RUN: llc < %s | grep lfd | count 2
-; RUN: llc < %s | grep lfs | count 2
+; RUN: llc -mattr=-vsx < %s | grep stfd | count 3
+; RUN: llc -mattr=-vsx < %s | grep stfs | count 1
+; RUN: llc -mattr=-vsx < %s | grep lfd | count 2
+; RUN: llc -mattr=-vsx < %s | grep lfs | count 2
+; RUN: llc -mattr=+vsx < %s | grep stxsdx | count 3
+; RUN: llc -mattr=+vsx < %s | grep stfs | count 1
+; RUN: llc -mattr=+vsx < %s | grep lxsdx | count 2
+; RUN: llc -mattr=+vsx < %s | grep lfs | count 2

This appears unrelated to fast-isel?

+++ /home/seurer/llvm/llvm-test/test/CodeGen/PowerPC/2012-10-12-bitcast.ll
@@ -1,4 +1,5 @@
-; RUN: llc -mattr=+altivec < %s | FileCheck %s
+; RUN: llc -mattr=-vsx -mattr=+altivec < %s | FileCheck %s
+; RUN: llc -mattr=+vsx -mattr=+altivec < %s | FileCheck -check-prefix=VSX %s

Ditto.

+++ /home/seurer/llvm/llvm-test/test/CodeGen/PowerPC/buildvec_canonicalize.ll
@@ -1,4 +1,5 @@
-; RUN: llc < %s -march=ppc32 -mattr=+altivec --enable-unsafe-fp-math

FileCheck %s

+; RUN: llc < %s -mattr=-vsx -march=ppc32 -mattr=+altivec
--enable-unsafe-fp-math | FileCheck %s
+; RUN: llc < %s -mattr=+vsx -march=ppc32 -mattr=+altivec
--enable-unsafe-fp-math | FileCheck -check-prefix=VSX %s

Ditto.

+++ /home/seurer/llvm/llvm-test/test/CodeGen/PowerPC/copysignl.ll
@@ -1,4 +1,5 @@
-; RUN: llc -mcpu=pwr7 -mtriple=powerpc64-unknown-linux-gnu < %s | FileCheck %s
+; RUN: llc -mcpu=pwr7 -mtriple=powerpc64-unknown-linux-gnu
-mattr=-vsx < %s | FileCheck %s -check-prefix=NOVSX
+; RUN: llc -mcpu=pwr7 -mtriple=powerpc64-unknown-linux-gnu
-mattr=+vsx < %s | FileCheck %s -check-prefix=VSX

Ditto.

+++ /home/seurer/llvm/llvm-test/test/CodeGen/PowerPC/fabs.ll
@@ -1,4 +1,5 @@
-; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin | grep "fabs f1, f1"
+; RUN: llc < %s -mattr=-vsx -march=ppc32
-mtriple=powerpc-apple-darwin | grep "fabs f1, f1"
+; RUN: llc < %s -mattr=+vsx -march=ppc32
-mtriple=powerpc-apple-darwin | grep "xsabsdp f1, f1"

Ditto.

+++ /home/seurer/llvm/llvm-test/test/CodeGen/PowerPC/fast-isel-call.ll
@@ -1,4 +1,4 @@
-; RUN: llc < %s -O0 -verify-machineinstrs -fast-isel-abort
-mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7 | FileCheck %s
--check-prefix=ELF64
+; RUN: llc < %s -O0 -verify-machineinstrs -mattr=-vsx
-fast-isel-abort -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7 |
FileCheck %s --check-prefix=ELF64

Do we really want to change almost every pwr7 fast isel test to remove
the vsx attribute just because bits of the tests don't work? I'm not
sure I've got a better solution, but this seems really heavy handed.

-; ELF64-LABEL: ret2
+; ELF64: ret2

Seems an orthogonal change?

+++ /home/seurer/llvm/llvm-test/test/CodeGen/PowerPC/fma.ll
@@ -1,4 +1,4 @@
-; RUN: llc < %s -march=ppc32 -fp-contract=fast | FileCheck %s
+; RUN: llc < %s -mattr=-vsx -march=ppc32 -fp-contract=fast | FileCheck %s

This appears unrelated to fast-isel? (Along with everything that
doesn't use -O0 on the llc command line).

+++ /home/seurer/llvm/llvm-test/test/CodeGen/PowerPC/fsel.ll
@@ -1,5 +1,6 @@
-; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7 | FileCheck %s
-; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7
-enable-no-infs-fp-math -enable-no-nans-fp-math | FileCheck
-check-prefix=CHECK-FM %s
+; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7
-mattr=-vsx | FileCheck %s
+; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7
-enable-no-infs-fp-math -enable-no-nans-fp-math -mattr=-vsx |
FileCheck -check-prefix=CHECK-FM %s
+; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7
-enable-no-infs-fp-math -enable-no-nans-fp-math -mattr=+vsx |
FileCheck -check-prefix=CHECK-FM-VSX %s
target datalayout =
"E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f128:128:128-v128:128:128-n32:64"
target triple = "powerpc64-unknown-linux-gnu"

@@ -16,6 +17,10 @@
; CHECK-FM: @zerocmp1
; CHECK-FM: fsel 1, 1, 2, 3
; CHECK-FM: blr
+
+; CHECK-FM-VSX: @zerocmp1
+; CHECK-FM-VSX: fsel 1, 1, 2, 3
+; CHECK-FM-VSX: blr

Another orthogonal test change?

There's more seemingly of these as well, but calling out each one
separately seems to be a bit verbose.

Thoughts?

-eric

[seurer]

As per the discussion I have changed this to only contain the code fixes.

[wschmidt]

The current diff looks fine to me, and I'd be happy to commit it for you. Eric, I had difficulty parsing your last comment, but I believe this follows the direction you were pursuing. Any problem with moving forward on this one?

[wschmidt]

/me adds a light and airy *ping* to the discussion thread. ;)

[wschmidt]

I've been thinking about this a bit more, and I'm not very happy with a solution that changes the general FastISel machinery, given that it's intended to be temporary. I think seurer is making pretty good progress on the real solution for VSX in FastISel, so it might be best to suck it up and wait for that to be completed. Thoughts?

BTW, from a note he sent me this morning I have a feeling that FastISel may be ignoring AddedComplexity in the pattern selection code. The VSX pattern should be preferred over the other when available, but the non-VSX pattern code is being generated first, which doesn't give the VSX pattern a chance. Eric, is this possible?

[echristo]

In D5362#35, @wschmidt wrote:

I've been thinking about this a bit more, and I'm not very happy with a solution that changes the general FastISel machinery, given that it's intended to be temporary. I think seurer is making pretty good progress on the real solution for VSX in FastISel, so it might be best to suck it up and wait for that to be completed. Thoughts?

This is definitely my preference here. As a temporary solution I'm absolutely ok with checking if VSX is enabled and just disabling fastisel.

BTW, from a note he sent me this morning I have a feeling that FastISel may be ignoring AddedComplexity in the pattern selection code. The VSX pattern should be preferred over the other when available, but the non-VSX pattern code is being generated first, which doesn't give the VSX pattern a chance. Eric, is this possible?

I'm fairly certain we don't pay attention to AddedComplexity in fast isel. One solution would be to change the order of those patterns in the file I think. At least might be worth a try.

-eric

[seurer]

Superseded by [llvm] r223507

/home/seurer/llvm/llvm-oneoff/include/llvm/CodeGen/FastISel.h

protected:
   virtual unsigned fastMaterializeAlloca(const AllocaInst *C) { return 0; }
 
   /// \brief Emit the floating-point constant +0.0 in a register using target-
   /// specific logic.
   virtual unsigned fastMaterializeFloatZero(const ConstantFP *CF) {
     return 0;
   }
 
+  /// \brief Verify that a type is valid for FastISel.  Should be overriden
+  /// by targets with more restrictive type legality in FastIsel.
+  virtual bool isTypeLegal(EVT Evt) const {
+    return TLI.isTypeLegal(Evt);
+  }
+
   /// \brief Check if \c Add is an add that can be safely folded into \c GEP.
   ///
   /// \c Add can be folded into \c GEP if:
   /// - \c Add is an add,
   /// - \c Add's size matches \c GEP's,
   /// - \c Add is in the same basic block as \c GEP, and
   /// - \c Add has a constant operand.
   bool canFoldAddIntoGEP(const User *GEP, const Value *Add);

/home/seurer/llvm/llvm-oneoff/lib/CodeGen/SelectionDAG/FastISel.cpp

unsigned FastISel::getRegForValue(const Value *V) {
   // Don't handle non-simple values in FastISel.
   if (!RealVT.isSimple())
     return 0;
 
   // Ignore illegal types. We must do this before looking up the value
   // in ValueMap because Arguments are given virtual registers regardless
   // of whether FastISel can handle them.
   MVT VT = RealVT.getSimpleVT();
-  if (!TLI.isTypeLegal(VT)) {
+  if (!isTypeLegal(VT)) {
     // Handle integer promotions, though, because they're common and easy.
     if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16)
       VT = TLI.getTypeToTransformTo(V->getContext(), VT).getSimpleVT();
     else
       return 0;
   }
 
   // Look up the value to see if we already have a register for it.
bool FastISel::selectBinaryOp(const User *I, unsigned ISDOpcode) {
   if (VT == MVT::Other || !VT.isSimple())
     // Unhandled type. Halt "fast" selection and bail.
     return false;
 
   // We only handle legal types. For example, on x86-32 the instruction
   // selector contains all of the 64-bit instructions from x86-64,
   // under the assumption that i64 won't be used if the target doesn't
   // support it.
-  if (!TLI.isTypeLegal(VT)) {
+  if (!isTypeLegal(VT)) {
     // MVT::i1 is special. Allow AND, OR, or XOR because they
     // don't require additional zeroing, which makes them easy.
     if (VT == MVT::i1 && (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR ||
                           ISDOpcode == ISD::XOR))
       VT = TLI.getTypeToTransformTo(I->getContext(), VT);
     else
       return false;
   }
bool FastISel::selectCast(const User *I, unsigned Opcode) {
   EVT DstVT = TLI.getValueType(I->getType());
 
   if (SrcVT == MVT::Other || !SrcVT.isSimple() || DstVT == MVT::Other ||
       !DstVT.isSimple())
     // Unhandled type. Halt "fast" selection and bail.
     return false;
 
   // Check if the destination type is legal.
-  if (!TLI.isTypeLegal(DstVT))
+  if (!isTypeLegal(DstVT))
     return false;
 
   // Check if the source operand is legal.
-  if (!TLI.isTypeLegal(SrcVT))
+  if (!isTypeLegal(SrcVT))
     return false;
 
   unsigned InputReg = getRegForValue(I->getOperand(0));
   if (!InputReg)
     // Unhandled operand.  Halt "fast" selection and bail.
     return false;
 
   bool InputRegIsKill = hasTrivialKill(I->getOperand(0));
if (I->getType() == I->getOperand(0)->getType()) {
     updateValueMap(I, Reg);
     return true;
   }
 
   // Bitcasts of other values become reg-reg copies or BITCAST operators.
   EVT SrcEVT = TLI.getValueType(I->getOperand(0)->getType());
   EVT DstEVT = TLI.getValueType(I->getType());
   if (SrcEVT == MVT::Other || DstEVT == MVT::Other ||
-      !TLI.isTypeLegal(SrcEVT) || !TLI.isTypeLegal(DstEVT))
+      !isTypeLegal(SrcEVT) || !isTypeLegal(DstEVT))
     // Unhandled type. Halt "fast" selection and bail.
     return false;
 
   MVT SrcVT = SrcEVT.getSimpleVT();
   MVT DstVT = DstEVT.getSimpleVT();
   unsigned Op0 = getRegForValue(I->getOperand(0));
   if (!Op0) // Unhandled operand. Halt "fast" selection and bail.
     return false;
if (ResultReg) {
     return true;
   }
 
   // Bitcast the value to integer, twiddle the sign bit with xor,
   // and then bitcast it back to floating-point.
   if (VT.getSizeInBits() > 64)
     return false;
   EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits());
-  if (!TLI.isTypeLegal(IntVT))
+  if (!isTypeLegal(IntVT))
     return false;
 
   unsigned IntReg = fastEmit_r(VT.getSimpleVT(), IntVT.getSimpleVT(),
                                ISD::BITCAST, OpReg, OpRegIsKill);
   if (!IntReg)
     return false;
 
   unsigned IntResultReg = fastEmit_ri_(
if (!EVI)
     return false;
 
   // Make sure we only try to handle extracts with a legal result.  But also
   // allow i1 because it's easy.
   EVT RealVT = TLI.getValueType(EVI->getType(), /*AllowUnknown=*/true);
   if (!RealVT.isSimple())
     return false;
   MVT VT = RealVT.getSimpleVT();
-  if (!TLI.isTypeLegal(VT) && VT != MVT::i1)
+  if (!isTypeLegal(VT) && VT != MVT::i1)
     return false;
 
   const Value *Op0 = EVI->getOperand(0);
   Type *AggTy = Op0->getType();
 
   // Get the base result register.
   unsigned ResultReg;
   DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(Op0);
for (BasicBlock::const_iterator I = SuccBB->begin();
 
       // Only handle legal types. Two interesting things to note here. First,
       // by bailing out early, we may leave behind some dead instructions,
       // since SelectionDAG's HandlePHINodesInSuccessorBlocks will insert its
       // own moves. Second, this check is necessary because FastISel doesn't
       // use CreateRegs to create registers, so it always creates
       // exactly one register for each non-void instruction.
       EVT VT = TLI.getValueType(PN->getType(), /*AllowUnknown=*/true);
-      if (VT == MVT::Other || !TLI.isTypeLegal(VT)) {
+      if (VT == MVT::Other || !isTypeLegal(VT)) {
         // Handle integer promotions, though, because they're common and easy.
         if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16)
           VT = TLI.getTypeToTransformTo(LLVMBB->getContext(), VT);
         else {
           FuncInfo.PHINodesToUpdate.resize(FuncInfo.OrigNumPHINodesToUpdate);
           return false;
         }
       }

/home/seurer/llvm/llvm-oneoff/lib/Target/PowerPC/PPCFastISel.cpp

unsigned fastEmitInst_ri(unsigned MachineInstOpcode,
                              uint64_t Imm);
     unsigned fastEmitInst_r(unsigned MachineInstOpcode,
                             const TargetRegisterClass *RC,
                             unsigned Op0, bool Op0IsKill);
     unsigned fastEmitInst_rr(unsigned MachineInstOpcode,
                              const TargetRegisterClass *RC,
                              unsigned Op0, bool Op0IsKill,
                              unsigned Op1, bool Op1IsKill);
+    bool isTypeLegal(EVT VT) const override;
 
   // Instruction selection routines.
   private:
     bool SelectLoad(const Instruction *I);
     bool SelectStore(const Instruction *I);
     bool SelectBranch(const Instruction *I);
     bool SelectIndirectBr(const Instruction *I);
     bool SelectFPExt(const Instruction *I);
     bool SelectFPTrunc(const Instruction *I);
     bool SelectIToFP(const Instruction *I, bool IsSigned);
     bool SelectFPToI(const Instruction *I, bool IsSigned);
     bool SelectBinaryIntOp(const Instruction *I, unsigned ISDOpcode);
     bool SelectCall(const Instruction *I);
     bool SelectRet(const Instruction *I);
     bool SelectTrunc(const Instruction *I);
     bool SelectIntExt(const Instruction *I);
 
   // Utility routines.
   private:
-    bool isTypeLegal(Type *Ty, MVT &VT);
+    bool isTypeLegalCommon(EVT Evt, MVT &VT) const;
+    bool isTypeLegal(Type *Ty, MVT &VT) const;
     bool isLoadTypeLegal(Type *Ty, MVT &VT);
     bool PPCEmitCmp(const Value *Src1Value, const Value *Src2Value,
                     bool isZExt, unsigned DestReg);
     bool PPCEmitLoad(MVT VT, unsigned &ResultReg, Address &Addr,
                      const TargetRegisterClass *RC, bool IsZExt = true,
                      unsigned FP64LoadOpc = PPC::LFD);
     bool PPCEmitStore(MVT VT, unsigned SrcReg, Address &Addr);
     bool PPCComputeAddress(const Value *Obj, Address &Addr);
switch (Pred) {
     case CmpInst::FCMP_ORD:
       return PPC::PRED_NU;
 
     case CmpInst::FCMP_UNO:
       return PPC::PRED_UN;
   }
 }
 
-// Determine whether the type Ty is simple enough to be handled by
-// fast-isel, and return its equivalent machine type in VT.
-// FIXME: Copied directly from ARM -- factor into base class?
-bool PPCFastISel::isTypeLegal(Type *Ty, MVT &VT) {
-  EVT Evt = TLI.getValueType(Ty, true);
-
+// Utility function for the following two functions that determines
+// whether the extended value type Evt is simple enough to be handled
+// by fast-isel.  The equivalent machine type is returned in VT.
+bool PPCFastISel::isTypeLegalCommon(EVT Evt, MVT &VT) const {
   // Only handle simple types.
   if (Evt == MVT::Other || !Evt.isSimple()) return false;
+  // Note: overwrites VT's (second parameter's) value
   VT = Evt.getSimpleVT();
 
+  // FastISel can't handle VSX registers (yet).
+  // FIXME: remove when VSX support is added.
+  if (PPCSubTarget->hasVSX() && (VT.isVector() || VT == MVT::f64)) {    
+   return false;
+  }
+
   // Handle all legal types, i.e. a register that will directly hold this
   // value.
   return TLI.isTypeLegal(VT);
 }
 
 // Determine whether the type Ty is simple enough to be handled by
+// fast-isel, and return its equivalent machine type in VT.
+bool PPCFastISel::isTypeLegal(Type *Ty, MVT &VT) const {
+  EVT Evt = TLI.getValueType(Ty, true);
+  return isTypeLegalCommon(Evt, VT);
+}
+
+// Determine whether the extended value type Evt is simple enough to be handled
+// by fast-isel.
+bool PPCFastISel::isTypeLegal(EVT Evt) const {
+  MVT VT;
+  return isTypeLegalCommon(Evt, VT);
+}
+
+// Determine whether the type Ty is simple enough to be handled by
 // fast-isel as a load target, and return its equivalent machine type in VT.
 bool PPCFastISel::isLoadTypeLegal(Type *Ty, MVT &VT) {
   if (isTypeLegal(Ty, VT)) return true;
 
   // If this is a type than can be sign or zero-extended to a basic operation
   // go ahead and accept it now.
   if (VT == MVT::i8 || VT == MVT::i16 || VT == MVT::i32) {
     return true;
if (isa<ConstantInt>(*RV)) {
 
       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
             TII.get(TargetOpcode::COPY), RetReg).addReg(SrcReg);
 
       RetRegs.push_back(RetReg);
 
     } else {
       unsigned Reg = getRegForValue(RV);
-
       if (Reg == 0)
         return false;
 
       // Copy the result values into the output registers.
       for (unsigned i = 0; i < ValLocs.size(); ++i) {
 
         CCValAssign &VA = ValLocs[i];
         assert(VA.isRegLoc() && "Can only return in registers!");