Remove error-recovery TODO comments from bitcode parser.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 508 matching lines @@
 }
 
 Ice::FunctionDeclaration *
 TopLevelParser::reportGetFunctionByIDError(NaClBcIndexSize_t ID) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Function index " << ID
          << " not allowed. Out of range. Must be less than "
          << FunctionDeclarationList.size();
   blockError(StrBuf.str());
-  // TODO(kschimpf) Remove error recovery once implementation complete.
   if (!FunctionDeclarationList.empty())
     return FunctionDeclarationList[0];
   Fatal();
 }
 
 Ice::VariableDeclaration *
 TopLevelParser::reportGetGlobalVariableByIDError(NaClBcIndexSize_t Index) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Global index " << Index
          << " not allowed. Out of range. Must be less than "
          << VariableDeclarations->size();
   blockError(StrBuf.str());
-  // TODO(kschimpf) Remove error recovery once implementation complete.
   if (!VariableDeclarations->empty())
     return VariableDeclarations->at(0);
   Fatal();
 }
 
 Ice::Type TopLevelParser::convertToIceTypeError(Type *LLVMTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid LLVM type: " << *LLVMTy;
   Error(StrBuf.str());
@@ skipping 150 matching lines @@
   Error(StrBuf.str());
 }
 
 bool BlockParserBaseClass::ParseBlock(unsigned BlockID) {
   // If called, derived class doesn't know how to handle block.
   // Report error and skip.
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Don't know how to parse block id: " << BlockID;
   Error(StrBuf.str());
-  // TODO(kschimpf) Remove error recovery once implementation complete.
   SkipBlock();
   return false;
 }
 
 void BlockParserBaseClass::ProcessRecord() {
   // If called, derived class doesn't know how to handle.
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Don't know how to process " << getBlockName()
          << " record:" << Record;
@@ skipping 185 matching lines @@
     for (size_t i = 2, e = Values.size(); i != e; ++i) {
       // Check that type void not used as argument type.
       // Note: PNaCl restrictions can't be checked until we
       // know the name, because we have to check for intrinsic signatures.
       Ice::Type ArgTy = Context->getSimpleTypeByID(Values[i]);
       if (ArgTy == Ice::IceType_void) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Type for parameter " << (i - 1)
                << " not valid. Found: " << ArgTy;
-        // TODO(kschimpf) Remove error recovery once implementation complete.
         ArgTy = Ice::IceType_i32;
       }
       FuncTy->appendArgType(ArgTy);
     }
     return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
     return;
   }
@@ skipping 459 matching lines @@
   bool verifyAllForwardRefsDefined();
 
   // 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(NaClBcIndexSize_t Index) {
     assert(!isIRGenerationDisabled());
     if (Index == 0) {
       Error("Branch to entry block not allowed");
-      // TODO(kschimpf) Remove error recovery once implementation complete.
     }
     return getBasicBlock(Index);
   }
 
   // Generate an instruction variable with type Ty.
   Ice::Variable *createInstVar(Ice::Type Ty) {
     assert(!isIRGenerationDisabled());
     if (Ty == Ice::IceType_void) {
       Error("Can't define instruction value using type void");
       // Recover since we can't throw an exception.
@@ skipping 15 matching lines @@
           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.
   NaClBcIndexSize_t convertRelativeToAbsIndex(NaClRelBcIndexSize_t Id,
                                               NaClRelBcIndexSize_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;
   }
 
   // Sets element Index (in the local operands list) to Op.
   void setOperand(NaClBcIndexSize_t Index, Ice::Operand *Op) {
     assert(Op || isIRGenerationDisabled());
     // Check if simple push works.
     NaClBcIndexSize_t LocalIndex = Index - CachedNumGlobalValueIDs;
 
     // If element not defined, set it.
     Ice::Operand *&IndexedOp = LocalOperands[LocalIndex];
     if (IndexedOp == nullptr) {
       IndexedOp = Op;
       return;
     }
 
     // See if forward reference matchers.
     if (IndexedOp == Op)
       return;
 
     // Error has occurred.
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Multiple definitions for index " << Index << ": " << *Op
            << " and " << *IndexedOp;
     Error(StrBuf.str());
-    // TODO(kschimpf) Remove error recovery once implementation complete.
     IndexedOp = Op;
   }
 
   // Returns the relative operand (wrt to BaseIndex) referenced by
   // the given value Index.
   Ice::Operand *getRelativeOperand(NaClBcIndexSize_t Index,
                                    NaClBcIndexSize_t BaseIndex) {
     return getOperand(convertRelativeToAbsIndex(Index, BaseIndex));
   }
 
@@ skipping 141 matching lines @@
   // type Ty, and sets Op to the corresponding ICE binary
   // opcode. Returns true if able to convert, false otherwise.
   bool convertBinopOpcode(unsigned Opcode, Ice::Type Ty,
                           Ice::InstArithmetic::OpKind &Op) {
     switch (Opcode) {
     default: {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Binary opcode " << Opcode << "not understood for type " << Ty;
       Error(StrBuf.str());
-      // TODO(kschimpf) Remove error recovery once implementation complete.
       Op = Ice::InstArithmetic::Add;
       return false;
     }
     case naclbitc::BINOP_ADD:
       if (Ice::isIntegerType(Ty)) {
         Op = Ice::InstArithmetic::Add;
         return isValidIntegerArithOp(Op, Ty);
       } else {
         Op = Ice::InstArithmetic::Fadd;
         return isValidFloatingArithOp(Op, Ty);
@@ skipping 148 matching lines @@
   bool convertCastOpToIceOp(uint64_t Opcode, Ice::Type SourceType,
                             Ice::Type TargetType,
                             Ice::InstCast::OpKind &CastKind) {
     bool Result;
     switch (Opcode) {
     default: {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Cast opcode " << Opcode << " not understood.\n";
       Error(StrBuf.str());
-      // TODO(kschimpf) Remove error recovery once implementation complete.
       CastKind = Ice::InstCast::Bitcast;
       return false;
     }
     case naclbitc::CAST_TRUNC:
       CastKind = Ice::InstCast::Trunc;
       Result = isIntTruncCastValid(SourceType, TargetType);
       break;
     case naclbitc::CAST_ZEXT:
       CastKind = Ice::InstCast::Zext;
       Result = isIntExtCastValid(SourceType, TargetType);
@@ skipping 142 matching lines @@
       return false;
     }
   }
 
   // Creates an error instruction, generating a value of type Ty, and
   // adds a placeholder so that instruction indices line up.
   // Some instructions, such as a call, will not generate a value
   // if the return type is void. In such cases, a placeholder value
   // for the badly formed instruction is not needed. Hence, if Ty is
   // void, an error instruction is not appended.
-  // TODO(kschimpf) Remove error recovery once implementation complete.
   void appendErrorInstruction(Ice::Type Ty) {
     // Note: we don't worry about downstream translation errors because
     // the function will not be translated if any errors occur.
     if (Ty == Ice::IceType_void)
       return;
     Ice::Variable *Var = getNextInstVar(Ty);
     CurrentNode->appendInst(Ice::InstAssign::create(Func.get(), Var, Var));
   }
 };
 
@@ skipping 72 matching lines @@
     return;
   // Before translating, check for blocks without instructions, and
   // insert unreachable. This shouldn't happen, but be safe.
   size_t Index = 0;
   for (Ice::CfgNode *Node : Func->getNodes()) {
     if (Node->getInsts().empty()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Basic block " << Index << " contains no instructions";
       Error(StrBuf.str());
-      // TODO(kschimpf) Remove error recovery once implementation complete.
       Node->appendInst(Ice::InstUnreachable::create(Func.get()));
     }
     ++Index;
   }
   Func->computeInOutEdges();
 }
 
 void FunctionParser::reportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op,
                                            Ice::Type OpTy) {
   std::string Buffer;
@@ skipping 17 matching lines @@
   // The base index for relative indexing.
   NaClBcIndexSize_t BaseIndex = getNextInstIndex();
   switch (Record.GetCode()) {
   case naclbitc::FUNC_CODE_DECLAREBLOCKS: {
     // DECLAREBLOCKS: [n]
     if (!isValidRecordSize(1, "count"))
       return;
     uint64_t NumBbsRaw = Values[0];
     if (NumBbsRaw == 0) {
       Error("Functions must contain at least one basic block.");
-      // TODO(kschimpf) Remove error recovery once implementation complete.
       NumBbsRaw = 1;
     } else if (NumBbsRaw > NaClBcIndexSize_t_Max) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "To many basic blocks specified: " << NumBbsRaw;
       Error(StrBuf.str());
       NumBbsRaw = NaClBcIndexSize_t_Max;
     }
     if (isIRGenerationDisabled())
       return;
@@ skipping 587 matching lines @@
       switch (IntrinsicInfo->validateCall(Inst, ArgIndex)) {
       case Ice::Intrinsics::IsValidCall:
         break;
       case Ice::Intrinsics::BadReturnType: {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Intrinsic call expects return type "
                << IntrinsicInfo->getReturnType()
                << ". Found: " << Inst->getReturnType();
         Error(StrBuf.str());
-        // TODO(kschimpf) Remove error recovery once implementation complete.
         break;
       }
       case Ice::Intrinsics::WrongNumOfArgs: {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Intrinsic call expects " << IntrinsicInfo->getNumArgs()
                << ". Found: " << Inst->getNumArgs();
         Error(StrBuf.str());
-        // TODO(kschimpf) Remove error recovery once implementation complete.
         break;
       }
       case Ice::Intrinsics::WrongCallArgType: {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Intrinsic call argument " << ArgIndex << " expects type "
                << IntrinsicInfo->getArgType(ArgIndex)
                << ". Found: " << Inst->getArg(ArgIndex)->getType();
         Error(StrBuf.str());
-        // TODO(kschimpf) Remove error recovery once implementation complete.
         break;
       }
       }
     }
 
     CurrentNode->appendInst(Inst);
     return;
   }
   case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF: {
     // FORWARDTYPEREF: [opval, ty]
@@ skipping 173 matching lines @@
     Error(StrBuf.str());
   }
 };
 
 void FunctionValuesymtabParser::setValueName(NaClBcIndexSize_t Index,
                                              StringType &Name) {
   // Note: We check when Index is too small, so that we can error recover
   // (FP->getOperand will create fatal error).
   if (Index < getFunctionParser()->getNumGlobalIDs()) {
     reportUnableToAssign("instruction", Index, Name);
-    // TODO(kschimpf) Remove error recovery once implementation complete.
     return;
   }
   if (isIRGenerationDisabled())
     return;
   Ice::Operand *Op = getFunctionParser()->getOperand(Index);
   if (Ice::Variable *V = dyn_cast<Ice::Variable>(Op)) {
     if (Ice::BuildDefs::dump()) {
       std::string Nm(Name.data(), Name.size());
       V->setName(getFunctionParser()->getFunc(), Nm);
     }
@@ skipping 249 matching lines @@
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     ErrStream
         << IRFilename
         << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice