Add branch instructions 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 847 matching lines @@
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Reference to basic block " << Index
              << " not found. Must be less than " << Nodes.size();
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Index = 0;
     }
     return Nodes[Index];
   }
 
+  // Returns the Index-th basic block in the list of basic blocks.
+  // Assumes Index corresponds to a branch instruction. Hence, if
+  // 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.

[Jim Stichnoth, 2014/09/04 21:58:17]

Maybe "return NULL;" here, to help propagate the error upward?

[Karl, 2014/09/05 15:33:08]

The only block we always know we can recover to is block 0. If we return NULL,
we shouldn't be generating an error.

However, as discussed with Jim, I added code to check if errors occurred while
generating a function block. If so, it will not do any downstream translation.

+    }
+    return GetBasicBlock(Index);
+  }
+
   // Generates the next available local variable using the given
   // type.  Note: if Ty is void, this function returns NULL.
   Ice::Variable *NextInstVar(Ice::Type Ty) {
     if (Ty == Ice::IceType_void)
       return NULL;
     Ice::Variable *Var = Func->makeVariable(Ty, CurrentNode);
     LocalOperands.push_back(Var);
     return Var;
   }
 
@@ skipping 408 matching lines @@
       Error(StrBuf.str());
     }
     // TODO(kschimpf): Restrict index to a legal constant index (once
     // constants can be defined).
     Ice::Variable *Dest = NextInstVar(EltType);
     Inst = Ice::InstInsertElement::create(Func, Dest, Vec, Elt, Index);
     break;
   }
   case naclbitc::FUNC_CODE_INST_RET: {
     // RET: [opval?]
-    InstIsTerminating = true;
     if (!isValidRecordSizeInRange(0, 1, "function block ret"))
       return;
     if (Values.size() == 0) {
       Inst = Ice::InstRet::create(Func);
     } else {
       Inst = Ice::InstRet::create(Func, getRelativeOperand(Values[0]));
     }
+    InstIsTerminating = true;
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_BR: {
+    if (Values.size() == 1) {
+      // BR: [bb#]
+      Ice::CfgNode *Block = getBranchBasicBlock(Values[0]);
+      if (Block == NULL) return;

[Jim Stichnoth, 2014/09/04 21:58:17]

return statement on separate line

[Karl, 2014/09/05 15:33:08]

Done.

+      Inst = Ice::InstBr::create(Func, Block);
+    } else {
+      // BR: [bb#, bb#, opval]
+      if (!isValidRecordSize(3, "function block branch"))
+        return;
+      Ice::Operand *Cond = getRelativeOperand(Values[2]);
+      if (Cond->getType() != Ice::IceType_i1) {
+        std::string Buffer;
+        raw_string_ostream StrBuf(Buffer);
+        StrBuf << "Branch condition not i1";
+        Error(StrBuf.str());
+        return;
+      }
+      Ice::CfgNode *ThenBlock = getBranchBasicBlock(Values[0]);
+      Ice::CfgNode *ElseBlock = getBranchBasicBlock(Values[1]);
+      if (ThenBlock == 0 || ElseBlock == 0) return;

[Jim Stichnoth, 2014/09/04 21:58:17]

return on separate line.  Also, NULL instead of 0.

[Karl, 2014/09/05 15:33:08]

Done.

+      Inst = Ice::InstBr::create(Func, Cond, ThenBlock, ElseBlock);
+    }
+    InstIsTerminating = true;
     break;
   }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     break;
   }
   if (Inst)
     CurrentNode->appendInst(Inst);
 }
@@ skipping 156 matching lines @@
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
   return;
 }
 
 } // end of namespace Ice