Subzero: Use 'override' as appropriate for C++11.

src/IceInst.cpp

 //===- subzero/src/IceInst.cpp - High-level instruction implementation ----===//
 //
 //                        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 Inst class, primarily the various
@@ skipping 178 matching lines @@
             LiveEnd[VarNum] = InstNumber;
           }
         }
       }
     }
   }
 }
 
 InstAlloca::InstAlloca(Cfg *Func, Operand *ByteCount, uint32_t AlignInBytes,
                        Variable *Dest)
-    : Inst(Func, Inst::Alloca, 1, Dest), AlignInBytes(AlignInBytes) {
+    : InstHighLevel(Func, Inst::Alloca, 1, Dest), AlignInBytes(AlignInBytes) {
   // Verify AlignInBytes is 0 or a power of 2.
   assert(AlignInBytes == 0 || llvm::isPowerOf2_32(AlignInBytes));
   addSource(ByteCount);
 }
 
 InstArithmetic::InstArithmetic(Cfg *Func, OpKind Op, Variable *Dest,
                                Operand *Source1, Operand *Source2)
-    : Inst(Func, Inst::Arithmetic, 2, Dest), Op(Op) {
+    : InstHighLevel(Func, Inst::Arithmetic, 2, Dest), Op(Op) {
   addSource(Source1);
   addSource(Source2);
 }
 
 const char *InstArithmetic::getOpName(OpKind Op) {
   size_t OpIndex = static_cast<size_t>(Op);
   return OpIndex < InstArithmetic::_num
              ? InstArithmeticAttributes[OpIndex].DisplayString
              : "???";
 }
 
 bool InstArithmetic::isCommutative() const {
   return InstArithmeticAttributes[getOp()].IsCommutative;
 }
 
 InstAssign::InstAssign(Cfg *Func, Variable *Dest, Operand *Source)
-    : Inst(Func, Inst::Assign, 1, Dest) {
+    : InstHighLevel(Func, Inst::Assign, 1, Dest) {
   addSource(Source);
 }
 
 // If TargetTrue==TargetFalse, we turn it into an unconditional
 // branch.  This ensures that, along with the 'switch' instruction
 // semantics, there is at most one edge from one node to another.
 InstBr::InstBr(Cfg *Func, Operand *Source, CfgNode *TargetTrue,
                CfgNode *TargetFalse)
-    : Inst(Func, Inst::Br, 1, NULL), TargetFalse(TargetFalse),
+    : InstHighLevel(Func, Inst::Br, 1, NULL), TargetFalse(TargetFalse),
       TargetTrue(TargetTrue) {
   if (TargetTrue == TargetFalse) {
     TargetTrue = NULL; // turn into unconditional version
   } else {
     addSource(Source);
   }
 }
 
 InstBr::InstBr(Cfg *Func, CfgNode *Target)
-    : Inst(Func, Inst::Br, 0, NULL), TargetFalse(Target), TargetTrue(NULL) {}
+    : InstHighLevel(Func, Inst::Br, 0, NULL), TargetFalse(Target),
+      TargetTrue(NULL) {}
 
 NodeList InstBr::getTerminatorEdges() const {
   NodeList OutEdges;
   OutEdges.push_back(TargetFalse);
   if (TargetTrue)
     OutEdges.push_back(TargetTrue);
   return OutEdges;
 }
 
 InstCast::InstCast(Cfg *Func, OpKind CastKind, Variable *Dest, Operand *Source)
-    : Inst(Func, Inst::Cast, 1, Dest), CastKind(CastKind) {
+    : InstHighLevel(Func, Inst::Cast, 1, Dest), CastKind(CastKind) {
   addSource(Source);
 }
 
 InstExtractElement::InstExtractElement(Cfg *Func, Variable *Dest,
                                        Operand *Source1, Operand *Source2)
-    : Inst(Func, Inst::ExtractElement, 2, Dest) {
+    : InstHighLevel(Func, Inst::ExtractElement, 2, Dest) {
   addSource(Source1);
   addSource(Source2);
 }
 
 InstFcmp::InstFcmp(Cfg *Func, FCond Condition, Variable *Dest, Operand *Source1,
                    Operand *Source2)
-    : Inst(Func, Inst::Fcmp, 2, Dest), Condition(Condition) {
+    : InstHighLevel(Func, Inst::Fcmp, 2, Dest), Condition(Condition) {
   addSource(Source1);
   addSource(Source2);
 }
 
 InstIcmp::InstIcmp(Cfg *Func, ICond Condition, Variable *Dest, Operand *Source1,
                    Operand *Source2)
-    : Inst(Func, Inst::Icmp, 2, Dest), Condition(Condition) {
+    : InstHighLevel(Func, Inst::Icmp, 2, Dest), Condition(Condition) {
   addSource(Source1);
   addSource(Source2);
 }
 
 InstInsertElement::InstInsertElement(Cfg *Func, Variable *Dest,
                                      Operand *Source1, Operand *Source2,
                                      Operand *Source3)
-    : Inst(Func, Inst::InsertElement, 3, Dest) {
+    : InstHighLevel(Func, Inst::InsertElement, 3, Dest) {
   addSource(Source1);
   addSource(Source2);
   addSource(Source3);
 }
 
 InstLoad::InstLoad(Cfg *Func, Variable *Dest, Operand *SourceAddr)
-    : Inst(Func, Inst::Load, 1, Dest) {
+    : InstHighLevel(Func, Inst::Load, 1, Dest) {
   addSource(SourceAddr);
 }
 
 InstPhi::InstPhi(Cfg *Func, SizeT MaxSrcs, Variable *Dest)
-    : Inst(Func, Phi, MaxSrcs, Dest) {
+    : InstHighLevel(Func, Phi, MaxSrcs, Dest) {
   Labels = Func->allocateArrayOf<CfgNode *>(MaxSrcs);
 }
 
 // TODO: A Switch instruction (and maybe others) can add duplicate
 // edges.  We may want to de-dup Phis and validate consistency (i.e.,
 // the source operands are the same for duplicate edges), though it
 // seems the current lowering code is OK with this situation.
 void InstPhi::addArgument(Operand *Source, CfgNode *Label) {
   Labels[getSrcSize()] = Label;
   addSource(Source);
@@ skipping 38 matching lines @@
 Inst *InstPhi::lower(Cfg *Func) {
   Variable *Dest = getDest();
   assert(Dest);
   IceString PhiName = Dest->getName() + "_phi";
   Variable *NewSrc = Func->makeVariable(Dest->getType(), PhiName);
   this->Dest = NewSrc;
   return InstAssign::create(Func, Dest, NewSrc);
 }
 
 InstRet::InstRet(Cfg *Func, Operand *RetValue)
-    : Inst(Func, Ret, RetValue ? 1 : 0, NULL) {
+    : InstHighLevel(Func, Ret, RetValue ? 1 : 0, NULL) {
   if (RetValue)
     addSource(RetValue);
 }
 
 InstSelect::InstSelect(Cfg *Func, Variable *Dest, Operand *Condition,
                        Operand *SourceTrue, Operand *SourceFalse)
-    : Inst(Func, Inst::Select, 3, Dest) {
+    : InstHighLevel(Func, Inst::Select, 3, Dest) {
   assert(typeElementType(Condition->getType()) == IceType_i1);
   addSource(Condition);
   addSource(SourceTrue);
   addSource(SourceFalse);
 }
 
 InstStore::InstStore(Cfg *Func, Operand *Data, Operand *Addr)
-    : Inst(Func, Inst::Store, 2, NULL) {
+    : InstHighLevel(Func, Inst::Store, 2, NULL) {
   addSource(Data);
   addSource(Addr);
 }
 
 InstSwitch::InstSwitch(Cfg *Func, SizeT NumCases, Operand *Source,
                        CfgNode *LabelDefault)
-    : Inst(Func, Inst::Switch, 1, NULL), LabelDefault(LabelDefault),
+    : InstHighLevel(Func, Inst::Switch, 1, NULL), LabelDefault(LabelDefault),
       NumCases(NumCases) {
   addSource(Source);
   Values = Func->allocateArrayOf<uint64_t>(NumCases);
   Labels = Func->allocateArrayOf<CfgNode *>(NumCases);
   // Initialize in case buggy code doesn't set all entries
   for (SizeT I = 0; I < NumCases; ++I) {
     Values[I] = 0;
     Labels[I] = NULL;
   }
 }
 
 void InstSwitch::addBranch(SizeT CaseIndex, uint64_t Value, CfgNode *Label) {
   assert(CaseIndex < NumCases);
   Values[CaseIndex] = Value;
   Labels[CaseIndex] = Label;
 }
 
 NodeList InstSwitch::getTerminatorEdges() const {
   NodeList OutEdges;
   OutEdges.push_back(LabelDefault);
   for (SizeT I = 0; I < NumCases; ++I) {
     OutEdges.push_back(Labels[I]);
   }
   return OutEdges;
 }
 
 InstUnreachable::InstUnreachable(Cfg *Func)
-    : Inst(Func, Inst::Unreachable, 0, NULL) {}
+    : InstHighLevel(Func, Inst::Unreachable, 0, NULL) {}
 
 InstFakeDef::InstFakeDef(Cfg *Func, Variable *Dest, Variable *Src)
-    : Inst(Func, Inst::FakeDef, Src ? 1 : 0, Dest) {
+    : InstHighLevel(Func, Inst::FakeDef, Src ? 1 : 0, Dest) {
   assert(Dest);
   if (Src)
     addSource(Src);
 }
 
 InstFakeUse::InstFakeUse(Cfg *Func, Variable *Src)
-    : Inst(Func, Inst::FakeUse, 1, NULL) {
+    : InstHighLevel(Func, Inst::FakeUse, 1, NULL) {
   assert(Src);
   addSource(Src);
 }
 
 InstFakeKill::InstFakeKill(Cfg *Func, const VarList &KilledRegs,
                            const Inst *Linked)
-    : Inst(Func, Inst::FakeKill, KilledRegs.size(), NULL), Linked(Linked) {
+    : InstHighLevel(Func, Inst::FakeKill, KilledRegs.size(), NULL),
+      Linked(Linked) {
   for (VarList::const_iterator I = KilledRegs.begin(), E = KilledRegs.end();
        I != E; ++I) {
     Variable *Var = *I;
     addSource(Var);
   }
 }
 
 // ======================== Dump routines ======================== //
 
 void Inst::dumpDecorated(const Cfg *Func) const {
@@ skipping 11 matching lines @@
     Str << buf;
   }
   Str << "  ";
   if (isDeleted())
     Str << "  //";
   dump(Func);
   dumpExtras(Func);
   Str << "\n";
 }
 
-void Inst::emit(const Cfg * /*Func*/) const {
-  llvm_unreachable("emit() called on a non-lowered instruction");
-}
-
-void Inst::emitIAS(const Cfg *Func) const { emit(Func); }
-
 void Inst::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " =~ ";
   dumpSources(Func);
 }
 
 void Inst::dumpExtras(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   bool First = true;
@@ skipping 279 matching lines @@
   Str << "kill.pseudo ";
   dumpSources(Func);
 }
 
 void InstTarget::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "[TARGET] ";
   Inst::dump(Func);
 }
 
-void InstTarget::dumpExtras(const Cfg *Func) const { Inst::dumpExtras(Func); }
-
 } // end of namespace Ice