Fix whitespace.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124270 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 58 insertions, 58 deletions

diff --git a/utils/TableGen/CodeGenInstruction.cpp b/utils/TableGen/CodeGenInstruction.cpp
index 241105f..e6e081f 100644
--- a/utils/TableGen/CodeGenInstruction.cpp
+++ b/utils/TableGen/CodeGenInstruction.cpp
@@ -28,15 +28,15 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
   isPredicable = false;
   hasOptionalDef = false;
   isVariadic = false;
-  
+
   DagInit *OutDI = R->getValueAsDag("OutOperandList");
-  
+
   if (DefInit *Init = dynamic_cast<DefInit*>(OutDI->getOperator())) {
     if (Init->getDef()->getName() != "outs")
       throw R->getName() + ": invalid def name for output list: use 'outs'";
   } else
     throw R->getName() + ": invalid output list: use 'outs'";
-  
+
   NumDefs = OutDI->getNumArgs();
 
   DagInit *InDI = R->getValueAsDag("InOperandList");
@@ -45,7 +45,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
       throw R->getName() + ": invalid def name for input list: use 'ins'";
   } else
     throw R->getName() + ": invalid input list: use 'ins'";
-  
+
   unsigned MIOperandNo = 0;
   std::set<std::string> OperandNames;
   for (unsigned i = 0, e = InDI->getNumArgs()+OutDI->getNumArgs(); i != e; ++i){
@@ -58,11 +58,11 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
       ArgInit = InDI->getArg(i-NumDefs);
       ArgName = InDI->getArgName(i-NumDefs);
     }
-    
+
     DefInit *Arg = dynamic_cast<DefInit*>(ArgInit);
     if (!Arg)
       throw "Illegal operand for the '" + R->getName() + "' instruction!";
-    
+
     Record *Rec = Arg->getDef();
     std::string PrintMethod = "printOperand";
     std::string EncoderMethod;
@@ -73,19 +73,19 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
       // If there is an explicit encoder method, use it.
       EncoderMethod = Rec->getValueAsString("EncoderMethod");
       MIOpInfo = Rec->getValueAsDag("MIOperandInfo");
-      
+
       // Verify that MIOpInfo has an 'ops' root value.
       if (!dynamic_cast<DefInit*>(MIOpInfo->getOperator()) ||
           dynamic_cast<DefInit*>(MIOpInfo->getOperator())
           ->getDef()->getName() != "ops")
         throw "Bad value for MIOperandInfo in operand '" + Rec->getName() +
         "'\n";
-      
+
       // If we have MIOpInfo, then we have #operands equal to number of entries
       // in MIOperandInfo.
       if (unsigned NumArgs = MIOpInfo->getNumArgs())
         NumOps = NumArgs;
-      
+
       if (Rec->isSubClassOf("PredicateOperand"))
         isPredicable = true;
       else if (Rec->isSubClassOf("OptionalDefOperand"))
@@ -97,7 +97,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
                Rec->getName() != "ptr_rc" && Rec->getName() != "unknown")
       throw "Unknown operand class '" + Rec->getName() +
       "' in '" + R->getName() + "' instruction!";
-    
+
     // Check that the operand has a name and that it's unique.
     if (ArgName.empty())
       throw "In instruction '" + R->getName() + "', operand #" + utostr(i) +
@@ -105,13 +105,13 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
     if (!OperandNames.insert(ArgName).second)
       throw "In instruction '" + R->getName() + "', operand #" + utostr(i) +
       " has the same name as a previous operand!";
-    
+
     OperandList.push_back(OperandInfo(Rec, ArgName, PrintMethod, EncoderMethod,
                                       MIOperandNo, NumOps, MIOpInfo));
     MIOperandNo += NumOps;
   }
-  
-  
+
+
   // Make sure the constraints list for each operand is large enough to hold
   // constraint info, even if none is present.
   for (unsigned i = 0, e = OperandList.size(); i != e; ++i)
@@ -126,7 +126,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
 unsigned CGIOperandList::getOperandNamed(StringRef Name) const {
   unsigned OpIdx;
   if (hasOperandNamed(Name, OpIdx)) return OpIdx;
-  throw "'" + TheDef->getName() + "' does not have an operand named '$" + 
+  throw "'" + TheDef->getName() + "' does not have an operand named '$" +
     Name.str() + "'!";
 }
 
@@ -147,10 +147,10 @@ std::pair<unsigned,unsigned>
 CGIOperandList::ParseOperandName(const std::string &Op, bool AllowWholeOp) {
   if (Op.empty() || Op[0] != '$')
     throw TheDef->getName() + ": Illegal operand name: '" + Op + "'";
-  
+
   std::string OpName = Op.substr(1);
   std::string SubOpName;
-  
+
   // Check to see if this is $foo.bar.
   std::string::size_type DotIdx = OpName.find_first_of(".");
   if (DotIdx != std::string::npos) {
@@ -159,30 +159,30 @@ CGIOperandList::ParseOperandName(const std::string &Op, bool AllowWholeOp) {
       throw TheDef->getName() + ": illegal empty suboperand name in '" +Op +"'";
     OpName = OpName.substr(0, DotIdx);
   }
-  
+
   unsigned OpIdx = getOperandNamed(OpName);
-  
+
   if (SubOpName.empty()) {  // If no suboperand name was specified:
     // If one was needed, throw.
     if (OperandList[OpIdx].MINumOperands > 1 && !AllowWholeOp &&
         SubOpName.empty())
       throw TheDef->getName() + ": Illegal to refer to"
       " whole operand part of complex operand '" + Op + "'";
-    
+
     // Otherwise, return the operand.
     return std::make_pair(OpIdx, 0U);
   }
-  
+
   // Find the suboperand number involved.
   DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo;
   if (MIOpInfo == 0)
     throw TheDef->getName() + ": unknown suboperand name in '" + Op + "'";
-  
+
   // Find the operand with the right name.
   for (unsigned i = 0, e = MIOpInfo->getNumArgs(); i != e; ++i)
     if (MIOpInfo->getArgName(i) == SubOpName)
       return std::make_pair(OpIdx, i);
-  
+
   // Otherwise, didn't find it!
   throw TheDef->getName() + ": unknown suboperand name in '" + Op + "'";
 }
@@ -199,7 +199,7 @@ static void ParseConstraint(const std::string &CStr, CGIOperandList &Ops) {
       throw "Illegal format for @earlyclobber constraint: '" + CStr + "'";
     Name = Name.substr(wpos);
     std::pair<unsigned,unsigned> Op = Ops.ParseOperandName(Name, false);
-    
+
     // Build the string for the operand
     if (!Ops[Op.first].Constraints[Op.second].isNone())
       throw "Operand '" + Name + "' cannot have multiple constraints!";
@@ -207,33 +207,33 @@ static void ParseConstraint(const std::string &CStr, CGIOperandList &Ops) {
     CGIOperandList::ConstraintInfo::getEarlyClobber();
     return;
   }
-  
+
   // Only other constraint is "TIED_TO" for now.
   std::string::size_type pos = CStr.find_first_of('=');
   assert(pos != std::string::npos && "Unrecognized constraint");
   start = CStr.find_first_not_of(" \t");
   std::string Name = CStr.substr(start, pos - start);
-  
+
   // TIED_TO: $src1 = $dst
   wpos = Name.find_first_of(" \t");
   if (wpos == std::string::npos)
     throw "Illegal format for tied-to constraint: '" + CStr + "'";
   std::string DestOpName = Name.substr(0, wpos);
   std::pair<unsigned,unsigned> DestOp = Ops.ParseOperandName(DestOpName, false);
-  
+
   Name = CStr.substr(pos+1);
   wpos = Name.find_first_not_of(" \t");
   if (wpos == std::string::npos)
     throw "Illegal format for tied-to constraint: '" + CStr + "'";
-  
+
   std::pair<unsigned,unsigned> SrcOp =
   Ops.ParseOperandName(Name.substr(wpos), false);
   if (SrcOp > DestOp)
     throw "Illegal tied-to operand constraint '" + CStr + "'";
-  
-  
+
+
   unsigned FlatOpNo = Ops.getFlattenedOperandNumber(SrcOp);
-  
+
   if (!Ops[DestOp.first].Constraints[DestOp.second].isNone())
     throw "Operand '" + DestOpName + "' cannot have multiple constraints!";
   Ops[DestOp.first].Constraints[DestOp.second] =
@@ -242,16 +242,16 @@ static void ParseConstraint(const std::string &CStr, CGIOperandList &Ops) {
 
 static void ParseConstraints(const std::string &CStr, CGIOperandList &Ops) {
   if (CStr.empty()) return;
-  
+
   const std::string delims(",");
   std::string::size_type bidx, eidx;
-  
+
   bidx = CStr.find_first_not_of(delims);
   while (bidx != std::string::npos) {
     eidx = CStr.find_first_of(delims, bidx);
     if (eidx == std::string::npos)
       eidx = CStr.length();
-    
+
     ParseConstraint(CStr.substr(bidx, eidx - bidx), Ops);
     bidx = CStr.find_first_not_of(delims, eidx);
   }
@@ -262,16 +262,16 @@ void CGIOperandList::ProcessDisableEncoding(std::string DisableEncoding) {
     std::string OpName;
     tie(OpName, DisableEncoding) = getToken(DisableEncoding, " ,\t");
     if (OpName.empty()) break;
-    
+
     // Figure out which operand this is.
     std::pair<unsigned,unsigned> Op = ParseOperandName(OpName, false);
-    
+
     // Mark the operand as not-to-be encoded.
     if (Op.second >= OperandList[Op.first].DoNotEncode.size())
       OperandList[Op.first].DoNotEncode.resize(Op.second+1);
     OperandList[Op.first].DoNotEncode[Op.second] = true;
   }
-  
+
 }
 
 //===----------------------------------------------------------------------===//
@@ -325,11 +325,11 @@ CodeGenInstruction::CodeGenInstruction(Record *R) : TheDef(R), Operands(R) {
 MVT::SimpleValueType CodeGenInstruction::
 HasOneImplicitDefWithKnownVT(const CodeGenTarget &TargetInfo) const {
   if (ImplicitDefs.empty()) return MVT::Other;
-  
+
   // Check to see if the first implicit def has a resolvable type.
   Record *FirstImplicitDef = ImplicitDefs[0];
   assert(FirstImplicitDef->isSubClassOf("Register"));
-  const std::vector<MVT::SimpleValueType> &RegVTs = 
+  const std::vector<MVT::SimpleValueType> &RegVTs =
     TargetInfo.getRegisterVTs(FirstImplicitDef);
   if (RegVTs.size() == 1)
     return RegVTs[0];
@@ -342,7 +342,7 @@ HasOneImplicitDefWithKnownVT(const CodeGenTarget &TargetInfo) const {
 std::string CodeGenInstruction::
 FlattenAsmStringVariants(StringRef Cur, unsigned Variant) {
   std::string Res = "";
-  
+
   for (;;) {
     // Find the start of the next variant string.
     size_t VariantsStart = 0;
@@ -351,14 +351,14 @@ FlattenAsmStringVariants(StringRef Cur, unsigned Variant) {
           (VariantsStart == 0 || (Cur[VariantsStart-1] != '$' &&
                                   Cur[VariantsStart-1] != '\\')))
         break;
-    
+
     // Add the prefix to the result.
     Res += Cur.slice(0, VariantsStart);
     if (VariantsStart == Cur.size())
       break;
-    
+
     ++VariantsStart; // Skip the '{'.
-    
+
     // Scan to the end of the variants string.
     size_t VariantsEnd = VariantsStart;
     unsigned NestedBraces = 1;
@@ -369,18 +369,18 @@ FlattenAsmStringVariants(StringRef Cur, unsigned Variant) {
       } else if (Cur[VariantsEnd] == '{')
         ++NestedBraces;
     }
-    
+
     // Select the Nth variant (or empty).
     StringRef Selection = Cur.slice(VariantsStart, VariantsEnd);
     for (unsigned i = 0; i != Variant; ++i)
       Selection = Selection.split('|').second;
     Res += Selection.split('|').first;
-    
+
     assert(VariantsEnd != Cur.size() &&
            "Unterminated variants in assembly string!");
     Cur = Cur.substr(VariantsEnd + 1);
   }
-  
+
   return Res;
 }
 
@@ -399,7 +399,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
     throw TGError(R->getLoc(), "result of inst alias should be an instruction");
 
   ResultInst = &T.getInstruction(DI->getDef());
-  
+
   // NameClass - If argument names are repeated, we need to verify they have
   // the same class.
   StringMap<Record*> NameClass;
@@ -417,7 +417,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
                     ADI->getDef()->getName() + "!");
     Entry = ADI->getDef();
   }
-    
+
   // Decode and validate the arguments of the result.
   unsigned AliasOpNo = 0;
   for (unsigned i = 0, e = ResultInst->Operands.size(); i != e; ++i) {
@@ -430,8 +430,8 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
                     " arguments, but " + ResultInst->TheDef->getName() +
                     " instruction expects " +
                     utostr(ResultInst->Operands.size()) + " operands!");
-    
-    
+
+
     Init *Arg = Result->getArg(AliasOpNo);
     Record *ResultOpRec = ResultInst->Operands[i].Rec;
 
@@ -441,16 +441,16 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
         if (!Result->getArgName(AliasOpNo).empty())
           throw TGError(R->getLoc(), "result fixed register argument must "
                         "not have a name!");
-        
+
         if (!ResultOpRec->isSubClassOf("RegisterClass"))
           throw TGError(R->getLoc(), "result fixed register argument is not "
                         "passed to a RegisterClass operand!");
-        
+
         if (!T.getRegisterClass(ResultOpRec).containsRegister(ADI->getDef()))
           throw TGError(R->getLoc(), "fixed register " +ADI->getDef()->getName()
                         + " is not a member of the " + ResultOpRec->getName() +
                         " register class!");
-                                                                              
+
         // Now that it is validated, add it.
         ResultOperands.push_back(ResultOperand(ADI->getDef()));
         ResultInstOperandIndex.push_back(i);
@@ -474,7 +474,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
         continue;
       }
     }
-    
+
     // If the operand is a record, it must have a name, and the record type must
     // match up with the instruction's argument type.
     if (DefInit *ADI = dynamic_cast<DefInit*>(Arg)) {
@@ -485,9 +485,9 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
       if (ADI->getDef() != ResultOpRec)
         throw TGError(R->getLoc(), "result argument #" + utostr(AliasOpNo) +
                       " declared with class " + ADI->getDef()->getName() +
-                      ", instruction operand is class " + 
+                      ", instruction operand is class " +
                       ResultOpRec->getName());
-      
+
       // Now that it is validated, add it.
       ResultOperands.push_back(ResultOperand(Result->getArgName(AliasOpNo),
                                              ADI->getDef()));
@@ -495,7 +495,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
       ++AliasOpNo;
       continue;
     }
-    
+
     if (IntInit *II = dynamic_cast<IntInit*>(Arg)) {
       // Integer arguments can't have names.
       if (!Result->getArgName(AliasOpNo).empty())
@@ -503,7 +503,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
                       " must not have a name!");
       if (ResultInst->Operands[i].MINumOperands != 1 ||
           !ResultOpRec->isSubClassOf("Operand"))
-        throw TGError(R->getLoc(), "invalid argument class " + 
+        throw TGError(R->getLoc(), "invalid argument class " +
                       ResultOpRec->getName() +
                       " for integer result operand!");
       ResultOperands.push_back(ResultOperand(II->getValue()));
@@ -514,7 +514,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
 
     throw TGError(R->getLoc(), "result of inst alias has unknown operand type");
   }
-  
+
   if (AliasOpNo != Result->getNumArgs())
     throw TGError(R->getLoc(), "result has " + utostr(Result->getNumArgs()) +
                   " arguments, but " + ResultInst->TheDef->getName() +