Add forward instruction declaration 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 796 matching lines @@
   FunctionParser &operator=(const FunctionParser &) LLVM_DELETED_FUNCTION;
   friend class FunctionValuesymtabParser;
 
 public:
   FunctionParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Func(new Ice::Cfg(getTranslator().getContext())), CurrentBbIndex(0),
         FcnId(Context->getNextFunctionBlockValueID()),
         LLVMFunc(cast<Function>(Context->getGlobalValueByID(FcnId))),
         CachedNumGlobalValueIDs(Context->getNumGlobalValueIDs()),
+        NextLocalInstIndex(Context->getNumGlobalValueIDs()),
         InstIsTerminating(false) {
     Func->setFunctionName(LLVMFunc->getName());
     Func->setReturnType(Context->convertToIceType(LLVMFunc->getReturnType()));
     Func->setInternal(LLVMFunc->hasInternalLinkage());
     CurrentNode = InstallNextBasicBlock();
     Func->setEntryNode(CurrentNode);
     for (Function::const_arg_iterator ArgI = LLVMFunc->arg_begin(),
                                       ArgE = LLVMFunc->arg_end();
          ArgI != ArgE; ++ArgI) {
       Func->addArg(getNextInstVar(Context->convertToIceType(ArgI->getType())));
     }
   }
 
   ~FunctionParser() LLVM_OVERRIDE;
 
   // Set the next constant ID to the given constant C.
-  void setNextConstantID(Ice::Constant *C) { LocalOperands.push_back(C); }
+  void setNextConstantID(Ice::Constant *C) {
+    setOperand(NextLocalInstIndex++, C);
+  }
 
 private:
   // Timer for reading function bitcode and converting to ICE.
   Ice::Timer TConvert;
   // The corresponding ICE function defined by the function block.
   Ice::Cfg *Func;
   // The index to the current basic block being built.
   uint32_t CurrentBbIndex;
   // The basic block being built.
   Ice::CfgNode *CurrentNode;
   // The ID for the function.
   unsigned FcnId;
   // The corresponding LLVM function.
   Function *LLVMFunc;
+  // Holds the dividing point between local and global absolute value indices.
+  uint32_t CachedNumGlobalValueIDs;
   // Holds operands local to the function block, based on indices
   // defined in the bitcode file.
   std::vector<Ice::Operand *> LocalOperands;
-  // Holds the dividing point between local and global absolute value indices.
-  uint32_t CachedNumGlobalValueIDs;
+  // Holds the index within LocalOperands corresponding to the next
+  // instruction that generates a value.
+  uint32_t NextLocalInstIndex;
   // True if the last processed instruction was a terminating
   // instruction.
   bool InstIsTerminating;
   // Upper limit of alignment power allowed by LLVM
   static const uint64_t AlignPowerLimit = 29;
 
   // Extracts the corresponding Alignment to use, given the AlignPower
   // (i.e. 2**AlignPower, or 0 if AlignPower == 0). InstName is the
   // name of the instruction the alignment appears in.
   void extractAlignment(const char *InstName, uint64_t AlignPower,
@@ skipping 40 matching lines @@
   // the branch references the entry block, it also generates a
   // corresponding error.
   Ice::CfgNode *getBranchBasicBlock(uint32_t Index) {
     if (Index == 0) {
       Error("Branch to entry block not allowed");
       // TODO(kschimpf) Remove error recovery once implementation complete.
     }
     return getBasicBlock(Index);
   }
 
-  // Generates the next available local variable using the given type.
-  Ice::Variable *getNextInstVar(Ice::Type Ty) {
+  // Generate an instruction variable with type Ty.
+  Ice::Variable *createInstVar(Ice::Type Ty) {
     if (Ty == Ice::IceType_void) {
       Error("Can't define instruction value using type void");
       // Recover since we can't throw an exception.
       Ty = Ice::IceType_i32;
     }
-    Ice::Variable *Var = Func->makeVariable(Ty, CurrentNode);
-    LocalOperands.push_back(Var);
+    return Func->makeVariable(Ty, CurrentNode);
+  }
+
+  // Generates the next available local variable using the given type.
+  Ice::Variable *getNextInstVar(Ice::Type Ty) {
+    assert(NextLocalInstIndex >= CachedNumGlobalValueIDs);
+    // Before creating one, see if a forwardtyperef has already defined it.
+    uint32_t LocalIndex = NextLocalInstIndex - CachedNumGlobalValueIDs;
+    if (LocalIndex < LocalOperands.size()) {
+      Ice::Operand *Op = LocalOperands[LocalIndex];
+      if (Op != NULL) {
+        if (Ice::Variable *Var = dyn_cast<Ice::Variable>(Op)) {
+          if (Var->getType() == Ty) {
+            ++NextLocalInstIndex;
+            return Var;
+          }
+        }
+        std::string Buffer;
+        raw_string_ostream StrBuf(Buffer);
+        StrBuf << "Illegal forward referenced instruction ("
+               << NextLocalInstIndex << "): " << *Op;
+        Error(StrBuf.str());
+        // TODO(kschimpf) Remove error recovery once implementation complete.
+        ++NextLocalInstIndex;
+        return createInstVar(Ty);
+      }
+    }
+    Ice::Variable *Var = createInstVar(Ty);
+    setOperand(NextLocalInstIndex++, Var);
     return Var;
   }
 
   // Converts a relative index (wrt to BaseIndex) to an absolute value
   // index.
   uint32_t convertRelativeToAbsIndex(int32_t Id, int32_t BaseIndex) {
     if (BaseIndex < Id) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Invalid relative value id: " << Id
              << " (must be <= " << BaseIndex << ")";
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       return 0;
     }
     return BaseIndex - Id;
   }
 
   // Returns the value referenced by the given value Index.
   Ice::Operand *getOperand(uint32_t Index) {
     if (Index < CachedNumGlobalValueIDs) {
       // TODO(kschimpf): Define implementation.
       report_fatal_error("getOperand of global addresses not implemented");
     }
     uint32_t LocalIndex = Index - CachedNumGlobalValueIDs;
     if (LocalIndex >= LocalOperands.size()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Value index " << Index << " out of range. Must be less than "
-             << (LocalOperands.size() + CachedNumGlobalValueIDs);
+      StrBuf << "Value index " << Index << " not defined!";
       Error(StrBuf.str());
       report_fatal_error("Unable to continue");
     }
-    return LocalOperands[LocalIndex];
+    Ice::Operand *Op = LocalOperands[LocalIndex];
+    if (Op == NULL) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Value index " << Index << " not defined!";
+      Error(StrBuf.str());
+      report_fatal_error("Unable to continue");
+    }
+    return Op;
+  }
+
+  // Sets element Index (in the local operands list) to Op.
+  void setOperand(uint32_t Index, Ice::Operand *Op) {
+    assert(Op);
+    // Check if simple push works.
+    uint32_t LocalIndex = Index - CachedNumGlobalValueIDs;
+    if (LocalIndex == LocalOperands.size()) {
+      LocalOperands.push_back(Op);
+      return;
+    }
+
+    // Must be forward reference, expand vector to accommodate.
+    if (LocalIndex >= LocalOperands.size())
+      LocalOperands.resize(LocalIndex+1);
+
+    // If element not defined, set it.
+    Ice::Operand *OldOp = LocalOperands[LocalIndex];
+    if (OldOp == NULL) {
+      LocalOperands[LocalIndex] = Op;
+      return;
+    }
+
+    // See if forward reference matches.
+    if (OldOp == Op)
+      return;
+
+    // Error has occurred.
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    StrBuf << "Multiple definitions for index " << Index
+           << ": " << *Op << " and " << *OldOp;
+    Error(StrBuf.str());
+    // TODO(kschimpf) Remove error recovery once implementation complete.
+    LocalOperands[LocalIndex] = Op;
   }
 
   // Returns the relative operand (wrt to BaseIndex) referenced by
   // the given value Index.
   Ice::Operand *getRelativeOperand(int32_t Index, int32_t BaseIndex) {
     return getOperand(convertRelativeToAbsIndex(Index, BaseIndex));
   }
 
   // Returns the absolute index of the next value generating instruction.
   uint32_t getNextInstIndex() const {
-    return CachedNumGlobalValueIDs + LocalOperands.size();
+    return NextLocalInstIndex;
   }
 
   // Generates type error message for binary operator Op
   // operating on Type OpTy.
   void ReportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy);
 
   // Validates if integer logical Op, for type OpTy, is valid.
   // Returns true if valid. Otherwise generates error message and
   // returns false.
   bool isValidIntegerLogicalOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
@@ skipping 718 matching lines @@
       return;
     Ice::Operand *Value = getRelativeOperand(Values[1], BaseIndex);
     unsigned Alignment;
     extractAlignment("Store", Values[2], Alignment);
     if (!isValidLoadStoreAlignment(Alignment, Value->getType(), "Store"))
       return;
     CurrentNode->appendInst(
         Ice::InstStore::create(Func, Value, Address, Alignment));
     break;
   }
+  case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF: {
+    // FORWARDTYPEREF: [opval, ty]
+    if (!isValidRecordSize(2, "function block forward type ref"))
+      return;
+    setOperand(Values[0], createInstVar(
+        Context->convertToIceType(Context->getTypeByID(Values[1]))));
+    break;
+  }
   case naclbitc::FUNC_CODE_INST_SWITCH:
   case naclbitc::FUNC_CODE_INST_CALL:
   case naclbitc::FUNC_CODE_INST_CALL_INDIRECT:
-  case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF:
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     break;
   }
 }
 
 /// Parses constants within a function block.
 class ConstantsParser : public BlockParserBaseClass {
   ConstantsParser(const ConstantsParser &) LLVM_DELETED_FUNCTION;
@@ skipping 384 matching lines @@
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
   return;
 }
 
 } // end of namespace Ice