Implement ARM32 switch lowering.

src/IceTargetLoweringARM32.cpp

 //===- subzero/src/IceTargetLoweringARM32.cpp - ARM32 lowering ------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringARM32 class, which consists almost
@@ skipping 1907 matching lines @@
     Variable *ValueR = legalizeToVar(Value);
     _str(ValueR, NewAddr);
   }
 }
 
 void TargetARM32::doAddressOptStore() {
   UnimplementedError(Func->getContext()->getFlags());
 }
 
 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*/) {
   UnimplementedError(Func->getContext()->getFlags());
 }
 
 // Turn an i64 Phi instruction into a pair of i32 Phi instructions, to
 // preserve integrity of liveness analysis.  Undef values are also
 // turned into zeroes, since loOperand() and hiOperand() don't expect
 // Undef input.
@@ skipping 326 matching lines @@
       << ".eabi_attribute 36, 1   @ Tag_FP_HP_extension\n"
       << ".eabi_attribute 38, 1   @ Tag_ABI_FP_16bit_format\n"
       << ".eabi_attribute 42, 1   @ Tag_MPextension_use\n"
       << ".eabi_attribute 68, 1   @ Tag_Virtualization_use\n";
   // Technically R9 is used for TLS with Sandboxing, and we reserve it.
   // However, for compatibility with current NaCl LLVM, don't claim that.
   Str << ".eabi_attribute 14, 3   @ Tag_ABI_PCS_R9_use: Not used\n";
 }
 
 } // end of namespace Ice