Add alloca instruction to Subzero bitcode reader.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        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 PNaCl bitcode file to Ice, to machine code
@@ skipping 1492 matching lines @@
       }
       Ice::CfgNode *ThenBlock = getBranchBasicBlock(Values[0]);
       Ice::CfgNode *ElseBlock = getBranchBasicBlock(Values[1]);
       if (ThenBlock == NULL || ElseBlock == NULL)
         return;
       Inst = Ice::InstBr::create(Func, Cond, ThenBlock, ElseBlock);
     }
     InstIsTerminating = true;
     break;
   }
+  case naclbitc::FUNC_CODE_INST_ALLOCA: {
+    // ALLOCA: [Size, align]
+    if (!isValidRecordSize(2, "function block alloca")) return;

[jvoung (off chromium), 2014/09/05 16:55:04]

return on separate line

[Karl, 2014/09/08 21:16:23]

Done.

+    Ice::Operand *ByteCount = getRelativeOperand(Values[0]);
+    if (ByteCount->getType() != Ice::IceType_i32) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Alloca on non-i32 value. Found: " << ByteCount;
+      Error(StrBuf.str());
+      return;
+    }
+    unsigned Align = static_cast<unsigned>(Values[1]);

[jvoung (off chromium), 2014/09/05 16:55:04]

Should probably check that Align <= 29 or so? I think the max that LLVM supports
(for arbitrary reasons) is 2 ** 29:
http://llvm.org/docs/LangRef.html#alloca-instruction

You don't want to shift "1 << 33" below, for example.

[Karl, 2014/09/08 21:16:23]

Good point.

+    Ice::Variable *Dest = NextInstVar(Context->getIcePointerType());
+    Inst = Ice::InstAlloca::create(Func, ByteCount, (1 << Align) >> 1, Dest);

[Jim Stichnoth, 2014/09/05 23:03:39]

Any reason why it isn't (1<<(Align-1)) as opposed to ((1<<Align)>>1)?

What happens when Align==0?  (This would be the major difference between the two
expression, I think.)

The LLVM alloca documentation doesn't say that the alignment must be a power of
2.  Is that a PNaCl simplification, or is the LLVM documentation wrong?

[Karl, 2014/09/08 21:16:23]

In LLVM and PNaCl, 0 is allowed, and hence the special calculation.
Also, while LLVM isn't explicit about the power of 2 for alloca, it is
elsewhere. In addition, the LLVM bitcode writer explicitly assumes this and
converts it to the nearest enclosing power of 2. I will make sure that we make
this explicit in the PNaCl documentation.

+    break;
+  }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     break;
   }
   if (Inst)
     CurrentNode->appendInst(Inst);
 }
 
 /// Parses the module block in the bitcode file.
@@ skipping 154 matching lines @@
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
   return;
 }
 
 } // end of namespace Ice