Implement ARM32 switch lowering.

src/IceTargetLoweringARM32.cpp

Index: src/IceTargetLoweringARM32.cpp
diff --git a/src/IceTargetLoweringARM32.cpp b/src/IceTargetLoweringARM32.cpp
index 9bb2386b387ff42631ad4dce6e8361e1f7b0e7f9..009ddbfef06312de11a29e5996d6c88121d95441 100644
--- a/src/IceTargetLoweringARM32.cpp
+++ b/src/IceTargetLoweringARM32.cpp
@@ -1925,8 +1925,35 @@ void TargetARM32::doAddressOptStore() {
 }
 
 void TargetARM32::lowerSwitch(const InstSwitch *Inst) {
-  (void)Inst;
-  UnimplementedError(Func->getContext()->getFlags());
+  // This implements the most naive possible lowering.
+  // cmp a,val[0]; jeq label[0]; cmp a,val[1]; jeq label[1]; ... jmp default
+  Operand *Src0 = Inst->getComparison();
+  SizeT NumCases = Inst->getNumCases();
+  if (Src0->getType() == IceType_i64) {
+    Variable *Src0Lo = legalizeToVar(loOperand(Src0));

[jvoung (off chromium), 2015/06/25 21:24:50]

Hmm maybe why the X86 version had "legalize(Src0);" before this, is if Src0 is
undef.

[jvoung (off chromium), 2015/06/29 16:51:47]

Well, there are other places in the ARM code which might not have done
legalize(X) prior to loOperand(X) or hiOperand(X), which I can audit and fix
later, if you want to leave a "TODO(jvoung): handle and test undef".


The problem is that legalize(X) for ARM is unlike the X86 version, where if X is
a large immediate then that is not considered legal as-is/pass-through. It only
checks for 32-bit constants that way, and does something silly for 64-bit
constants: it will try to move any 64-bit constant into a register. However,
with 64-bit constants that blows up because there aren't 64-bit registers. I.e.,
legalize() is really expecting loOperand/hiOperand to split the 64-bit thing
first, but loOperand() is expecting legalize() to handle undef.


If the motivation for calling legalize() prior to loOperand() is to handle
undef, perhaps we could just make loOperand()/hiOperand() also aware of undef.
The downside is that undef-legalization-knowledge leaks to two other methods (in
case we wanted to change the behavior from initializing to 0 to not initializing
at all, which is cheaper but non-deterministic). Either that or we split out the
undef legalization into a separate method "legalizeUndef" and call that for the
purposes of legalizing undef (instead of the more general legalize()), prior to
calling loOperand/hiOperand. This is assuming that the x86 cases where
legalize() is called prior to lo/hiOperand are only for legalizing undef and
nothing else.

[ascull, 2015/06/29 17:00:03]

Done.

+    Variable *Src0Hi = legalizeToVar(hiOperand(Src0));
+    for (SizeT I = 0; I < NumCases; ++I) {
+      Operand *ValueLo = Ctx->getConstantInt32(Inst->getValue(I));
+      Operand *ValueHi = Ctx->getConstantInt32(Inst->getValue(I) >> 32);
+      ValueLo = legalize(ValueLo, Legal_Reg | Legal_Flex);
+      ValueHi = legalize(ValueHi, Legal_Reg | Legal_Flex);
+      _cmp(Src0Lo, ValueLo);
+      _cmp(Src0Hi, ValueHi, CondARM32::EQ);

[jvoung (off chromium), 2015/06/25 21:24:50]

nice, use that predication =)

+      _br(Inst->getLabel(I), CondARM32::EQ);
+    }
+    _br(Inst->getLabelDefault());
+    return;
+  }
+ 
+  // 32 bit integer
+  Variable *Src0Var = legalizeToVar(Src0);
+  for (SizeT I = 0; I < NumCases; ++I) {
+    Operand *Value = Ctx->getConstantInt32(Inst->getValue(I));
+    Value = legalize(Value, Legal_Reg | Legal_Flex);
+    _cmp(Src0Var, Value);
+    _br(Inst->getLabel(I), CondARM32::EQ);
+  }
+  _br(Inst->getLabelDefault());
 }
 
 void TargetARM32::lowerUnreachable(const InstUnreachable * /*Inst*/) {