[Autobackout][FunctionalRegression]Revert of change: 7e12ced: Minor fixes and refactors

sys-igc · igcbot · commit a894cc90fad7 · 2025-12-18T03:24:14.000+01:00
- replace dyn_cast with cast where no null-check.

    - null init structs

    - const auto &amp; if possible

    - std::move if var goes out of scope

    - cast u32 to u64 to prevent overflow

    - emplace_back instead of ctor + push_back
diff --git a/IGC/AdaptorOCL/preprocess_spvir/PromoteSubByte.cpp b/IGC/AdaptorOCL/preprocess_spvir/PromoteSubByte.cpp
@@ -125,7 +125,7 @@ Value *PromoteSubByte::convertI1ToI8(Value *value, IRBuilder<> &builder) {
 
   auto zext = builder.CreateZExt(value, getOrCreatePromotedType(value->getType()));
   if (isa<Instruction>(zext) && isa<Instruction>(value)) {
-    cast<Instruction>(zext)->setDebugLoc(cast<Instruction>(value)->getDebugLoc());
+    dyn_cast<Instruction>(zext)->setDebugLoc(dyn_cast<Instruction>(value)->getDebugLoc());
   }
   return zext;
 }
@@ -142,16 +142,17 @@ Value *PromoteSubByte::convertI8ToI1(Value *value, IRBuilder<> &builder) {
 
   auto trunc = builder.CreateTrunc(value, createDemotedType(value->getType()));
   if (isa<Instruction>(trunc) && isa<Instruction>(value)) {
-    cast<Instruction>(trunc)->setDebugLoc(cast<Instruction>(value)->getDebugLoc());
+    dyn_cast<Instruction>(trunc)->setDebugLoc(dyn_cast<Instruction>(value)->getDebugLoc());
   }
   return trunc;
 }
 
 Value *PromoteSubByte::castAggregate(Value *value, Type *desiredType, IRBuilder<> &builder) {
 
   if (auto *srcST = dyn_cast<StructType>(value->getType())) {
-    auto *dstST = cast<StructType>(desiredType);
+    auto *dstST = dyn_cast<StructType>(desiredType);
 
+    IGC_ASSERT(srcST && dstST);
     IGC_ASSERT(srcST->getNumElements() == dstST->getNumElements());
 
     Value *Accum = PoisonValue::get(dstST);
@@ -168,8 +169,9 @@ Value *PromoteSubByte::castAggregate(Value *value, Type *desiredType, IRBuilder<
   }
 
   if (auto *srcAT = dyn_cast<ArrayType>(value->getType())) {
-    auto *dstAT = cast<ArrayType>(desiredType);
+    auto *dstAT = dyn_cast<ArrayType>(desiredType);
 
+    IGC_ASSERT(srcAT && dstAT);
     IGC_ASSERT(srcAT->getNumElements() == dstAT->getNumElements());
 
     auto *dstElType = dstAT->getElementType();
@@ -527,7 +529,7 @@ Function *PromoteSubByte::promoteFunction(Function *function) {
   }
 #endif
 
-  auto newFunction = Function::Create(cast<FunctionType>(getOrCreatePromotedType(function->getFunctionType())),
+  auto newFunction = Function::Create(dyn_cast<FunctionType>(getOrCreatePromotedType(function->getFunctionType())),
                                       function->getLinkage(), function->getName() + ".promoted", function->getParent());
 
   newFunction->setCallingConv(function->getCallingConv());
@@ -673,7 +675,7 @@ Constant *PromoteSubByte::promoteConstant(Constant *constant) {
     }
 
     auto newType = getOrCreatePromotedType(constantArray->getType());
-    return ConstantArray::get(cast<ArrayType>(newType), values);
+    return ConstantArray::get(dyn_cast<ArrayType>(newType), values);
   } else if (auto constantStruct = dyn_cast<ConstantStruct>(constant)) {
     if (!typeNeedsPromotion(constantStruct->getType())) {
       return constant;
@@ -685,11 +687,11 @@ Constant *PromoteSubByte::promoteConstant(Constant *constant) {
     }
 
     auto newType = getOrCreatePromotedType(constantStruct->getType());
-    return ConstantStruct::get(cast<StructType>(newType), values);
+    return ConstantStruct::get(dyn_cast<StructType>(newType), values);
   } else if (auto constantExpr = dyn_cast<ConstantExpr>(constant)) {
     if (constantExpr->isCast() && isa<GlobalValue>(constantExpr->getOperand(0))) {
       return ConstantExpr::getCast(constantExpr->getOpcode(),
-                                   cast<Constant>(getOrCreatePromotedValue(constantExpr->getOperand(0))),
+                                   dyn_cast<Constant>(getOrCreatePromotedValue(constantExpr->getOperand(0))),
                                    constantExpr->getType());
     }
     return constantExpr;
@@ -868,7 +870,7 @@ InlineAsm *PromoteSubByte::promoteInlineAsm(InlineAsm *inlineAsm) {
     return inlineAsm;
   }
 
-  return InlineAsm::get(cast<FunctionType>(getOrCreatePromotedType(inlineAsm->getFunctionType())),
+  return InlineAsm::get(dyn_cast<FunctionType>(getOrCreatePromotedType(inlineAsm->getFunctionType())),
                         inlineAsm->getAsmString(), inlineAsm->getConstraintString(), inlineAsm->hasSideEffects(),
                         inlineAsm->isAlignStack(), inlineAsm->getDialect());
 }
diff --git a/IGC/Compiler/CISACodeGen/CISABuilder.cpp b/IGC/Compiler/CISACodeGen/CISABuilder.cpp
@@ -3283,19 +3283,19 @@ void CEncoder::AddVISASymbol(std::string &symName, CVariable *cvar) {
 }
 
 void CEncoder::SaveOption(vISAOptions option, bool val) {
-  OptionValue entry{};
+  OptionValue entry;
   entry.type = OpType::ET_BOOL;
   entry.vBool = val;
   m_visaUserOptions.push_back(std::make_pair(option, entry));
 }
 void CEncoder::SaveOption(vISAOptions option, uint32_t val) {
-  OptionValue entry{};
+  OptionValue entry;
   entry.type = OpType::ET_INT32;
   entry.vInt32 = val;
   m_visaUserOptions.push_back(std::make_pair(option, entry));
 }
 void CEncoder::SaveOption(vISAOptions option, const char *val) {
-  OptionValue entry{};
+  OptionValue entry;
   entry.type = OpType::ET_CSTR;
   entry.vCstr = val;
   m_visaUserOptions.push_back(std::make_pair(option, entry));
diff --git a/IGC/Compiler/CISACodeGen/SinkCommonOffsetFromGEP.cpp b/IGC/Compiler/CISACodeGen/SinkCommonOffsetFromGEP.cpp
@@ -209,7 +209,7 @@ static std::vector<DivergentPointer> findDivergentPointers(BasicBlock *BB) {
     if (DP.Phi == nullptr)
       continue;
 
-    DivergentPointers.push_back(std::move(DP));
+    DivergentPointers.push_back(DP);
   }
   return DivergentPointers;
 }
@@ -286,7 +286,7 @@ bool DivergentPointersGroups::createAddNewGroups(const DivergentPointer &DP) {
     Group.Casts[BB] = ASC;
   }
   Group.Successor = DP.Phi->getParent();
-  PointerGroups.push_back(std::move(Group));
+  PointerGroups.push_back(Group);
   return true;
 }
 
diff --git a/IGC/Compiler/CodeGenContext.cpp b/IGC/Compiler/CodeGenContext.cpp
@@ -606,8 +606,8 @@ static bool isEntryPoint(const CodeGenContext *ctx, const llvm::Function *F) {
     return false;
   }
 
-  const auto &FuncMD = ctx->getModuleMetaData()->FuncMD;
-  const auto &FuncInfo = FuncMD.find(const_cast<llvm::Function *>(F));
+  auto &FuncMD = ctx->getModuleMetaData()->FuncMD;
+  auto FuncInfo = FuncMD.find(const_cast<llvm::Function *>(F));
   if (FuncInfo == FuncMD.end()) {
     return false;
   }
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASRetValuePropagator.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASRetValuePropagator.cpp
@@ -260,7 +260,7 @@ void GASRetValuePropagator::updateMetadata(Function *oldFunc, Function *newFunc)
   if (loc != FuncMD.end()) {
     auto funcInfo = loc->second;
     FuncMD.erase(oldFunc);
-    FuncMD[newFunc] = std::move(funcInfo);
+    FuncMD[newFunc] = funcInfo;
   }
 
   m_mdUtils->save(m_module->getContext());
diff --git a/IGC/DebugInfo/VISADebugDecoder.hpp b/IGC/DebugInfo/VISADebugDecoder.hpp
@@ -291,15 +291,15 @@ class DbgDecoder {
       for (unsigned int j = 0; j != count; j++) {
         uint32_t cisaOffset = read<uint32_t>(dbg);
         uint32_t genOffset = read<uint32_t>(dbg);
-        f.CISAOffsetMap.emplace_back(cisaOffset, f.relocOffset + genOffset);
+        f.CISAOffsetMap.push_back(std::make_pair(cisaOffset, f.relocOffset + genOffset));
       }
 
       // cisa index map
       count = read<uint32_t>(dbg);
       for (unsigned int j = 0; j != count; j++) {
         uint32_t cisaIndex = read<uint32_t>(dbg);
         uint32_t genOffset = read<uint32_t>(dbg);
-        f.CISAIndexMap.emplace_back(cisaIndex, f.relocOffset + genOffset);
+        f.CISAIndexMap.push_back(std::make_pair(cisaIndex, f.relocOffset + genOffset));
       }
 
       // var info
@@ -314,10 +314,10 @@ class DbgDecoder {
         auto countLRs = read<uint16_t>(dbg);
         for (unsigned int k = 0; k != countLRs; k++) {
           LiveIntervalsVISA lv = readLiveIntervalsVISA();
-          v.lrs.push_back(std::move(lv));
+          v.lrs.push_back(lv);
         }
 
-        f.Vars.push_back(std::move(v));
+        f.Vars.push_back(v);
       }
 
       // subroutines
@@ -335,7 +335,7 @@ class DbgDecoder {
           LiveIntervalsVISA lv = readLiveIntervalsVISA();
           sub.retval.push_back(lv);
         }
-        f.subs.push_back(std::move(sub));
+        f.subs.push_back(sub);
       }
 
       // call frame information
@@ -346,23 +346,23 @@ class DbgDecoder {
         for (unsigned int j = 0; j != count; j++) {
           LiveIntervalGenISA lv = readLiveIntervalGenISA();
           ;
-          f.cfi.befp.push_back(std::move(lv));
+          f.cfi.befp.push_back(lv);
         }
       }
       f.cfi.callerbefpValid = (bool)read<uint8_t>(dbg);
       if (f.cfi.callerbefpValid) {
         count = read<uint16_t>(dbg);
         for (unsigned int j = 0; j != count; j++) {
           LiveIntervalGenISA lv = readLiveIntervalGenISA();
-          f.cfi.callerbefp.push_back(std::move(lv));
+          f.cfi.callerbefp.push_back(lv);
         }
       }
       f.cfi.retAddrValid = (bool)read<uint8_t>(dbg);
       if (f.cfi.retAddrValid) {
         count = read<uint16_t>(dbg);
         for (unsigned int j = 0; j != count; j++) {
           LiveIntervalGenISA lv = readLiveIntervalGenISA();
-          f.cfi.retAddr.push_back(std::move(lv));
+          f.cfi.retAddr.push_back(lv);
         }
       }
       f.cfi.CEOffsetFromFPOff = read<uint16_t>(dbg);
@@ -374,7 +374,7 @@ class DbgDecoder {
         phyRegSave.numEntries = read<uint16_t>(dbg);
         for (unsigned int k = 0; k != phyRegSave.numEntries; k++)
           phyRegSave.data.push_back(readRegInfoMapping());
-        f.cfi.calleeSaveEntry.push_back(std::move(phyRegSave));
+        f.cfi.calleeSaveEntry.push_back(phyRegSave);
       }
 
       f.cfi.numCallerSaveEntries = read<uint32_t>(dbg);
@@ -384,10 +384,10 @@ class DbgDecoder {
         phyRegSave.numEntries = read<uint16_t>(dbg);
         for (unsigned int k = 0; k != phyRegSave.numEntries; k++)
           phyRegSave.data.push_back(readRegInfoMapping());
-        f.cfi.callerSaveEntry.push_back(std::move(phyRegSave));
+        f.cfi.callerSaveEntry.push_back(phyRegSave);
       }
 
-      compiledObjs.push_back(std::move(f));
+      compiledObjs.push_back(f);
     }
   }
 
diff --git a/IGC/VISALinkerDriver/VLD.cpp b/IGC/VISALinkerDriver/VLD.cpp
@@ -189,7 +189,7 @@ MoveEntryPointModuleToTheEnd(llvm::ArrayRef<IGC::VLD::SPVTranslationPair> InputM
   }
 
   if (HasEntryPointModule) {
-    RetPairs.push_back(std::move(EntryPointPair));
+    RetPairs.push_back(EntryPointPair);
   }
 
   return RetPairs;
diff --git a/IGC/common/IGCSPIRVParser.cpp b/IGC/common/IGCSPIRVParser.cpp
@@ -37,7 +37,7 @@ std::vector<std::string> SPIRVParser::getEntryPointNames(const StringRef binary)
       while (binary.data()[(offsetInWords + 3) * 4 + nameLength])
         nameLength++;
       std::string name = binary.substr((offsetInWords + 3) * 4, nameLength).str();
-      entryPointNames.push_back(std::move(name));
+      entryPointNames.push_back(name);
     }
     offsetInWords += opWordsCount; // skip instruction
   }
diff --git a/IGC/common/MDFrameWork.cpp b/IGC/common/MDFrameWork.cpp
@@ -325,7 +325,7 @@ template <typename T> void readNode(std::vector<T> &vec, MDNode *node) {
   for (unsigned k = 1; k < node->getNumOperands(); k++) {
     T vecEle;
     readNode(vecEle, cast<MDNode>(node->getOperand(k)));
-    vec.push_back(std::move(vecEle));
+    vec.push_back(vecEle);
   }
   return;
 }
@@ -380,7 +380,7 @@ template <typename Key, typename Value> void readNode(std::map<Key, Value> &keyM
     std::pair<Key, Value> p;
     readNode(p.first, cast<MDNode>(node->getOperand(k++)));
     readNode(p.second, cast<MDNode>(node->getOperand(k)));
-    keyMD.insert(std::move(p));
+    keyMD.insert(p);
   }
   return;
 }
@@ -390,7 +390,7 @@ template <typename Key, typename Value> void readNode(MapVector<Key, Value> &key
     std::pair<Key, Value> p;
     readNode(p.first, cast<MDNode>(node->getOperand(k++)));
     readNode(p.second, cast<MDNode>(node->getOperand(k)));
-    keyMD.insert(std::move(p));
+    keyMD.insert(p);
   }
   return;
 }
@@ -399,7 +399,7 @@ template <typename Key> void readNode(std::set<Key> &keyMD, MDNode *node) {
   for (unsigned k = 1; k < node->getNumOperands(); k++) {
     Key key;
     readNode(key, cast<MDNode>(node->getOperand(k)));
-    keyMD.insert(std::move(key));
+    keyMD.insert(key);
   }
   return;
 }
@@ -408,7 +408,7 @@ template <typename Key> void readNode(SetVector<Key> &keyMD, MDNode *node) {
   for (unsigned k = 1; k < node->getNumOperands(); k++) {
     Key key;
     readNode(key, cast<MDNode>(node->getOperand(k)));
-    keyMD.insert(std::move(key));
+    keyMD.insert(key);
   }
   return;
 }
diff --git a/IGC/common/igc_regkeys.cpp b/IGC/common/igc_regkeys.cpp
@@ -667,7 +667,7 @@ static void ParseEntryPoint(llvm::StringRef line, std::vector<EntryPoint> &entry
     auto [token, RHS] = vString.split(',');
     EntryPoint entry_point{};
     entry_point.entry_point_name = token.str();
-    entry_points.push_back(std::move(entry_point));
+    entry_points.push_back(entry_point);
     vString = RHS;
   } while (!vString.empty());
 }
diff --git a/visa/iga/IGALibrary/IR/RegDeps.cpp b/visa/iga/IGALibrary/IR/RegDeps.cpp
@@ -579,8 +579,7 @@ void DepSet::addDependency(const RegRangeListType &reg_range) {
     // when range is max(), which means it's null, skip it
     if (pair.first == std::numeric_limits<uint32_t>::max())
       continue;
-    // u64 to avoid overflow if pair.second == ~0U
-    for (size_t regNum = pair.first; regNum <= pair.second; regNum++) {
+    for (uint32_t regNum = pair.first; regNum <= pair.second; regNum++) {
       addGrf(regNum);
       addToBucket(regNum);
     }
diff --git a/visa/iga/IGALibrary/IR/RegDeps.hpp b/visa/iga/IGALibrary/IR/RegDeps.hpp
@@ -141,7 +141,7 @@ class DepSet {
   void addGrfBytes(size_t reg, size_t subRegBytes, size_t bytes);
   void addABytesAndBukets(size_t reg);
   void addFBytes(size_t fByteOff, size_t bytes);
-  void addToBucket(size_t regNum) { m_bucketList.push_back(regNum); }
+  void addToBucket(uint32_t regNum) { m_bucketList.push_back(regNum); }
   void setDepPipe(DEP_PIPE pipe) { m_dPipe = pipe; }
   void setDepClass(DEP_CLASS cls) { m_dClass = cls; }
   void setSBID(SBID &sw) { m_sbid = sw; }
diff --git a/visa/iga/IGALibrary/api/iga.cpp b/visa/iga/IGALibrary/api/iga.cpp
@@ -136,7 +136,7 @@ struct PlatformNameMap {
         std::string str = mn.str();
         if (str.empty())
           break;
-        nmlist.push_back(std::move(str));
+        nmlist.push_back(str);
       }
       names[me.platform] = std::move(nmlist);
       exts[me.platform] = me.extension.str();

Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ static std::vector<DivergentPointer> findDivergentPointers(BasicBlock *BB) {`
`209`	`209`	`if (DP.Phi == nullptr)`
`210`	`210`	`continue;`
`211`	`211`
`212`		`- DivergentPointers.push_back(std::move(DP));`
	`212`	`+ DivergentPointers.push_back(DP);`
`213`	`213`	`}`
`214`	`214`	`return DivergentPointers;`
`215`	`215`	`}`
`@@ -286,7 +286,7 @@ bool DivergentPointersGroups::createAddNewGroups(const DivergentPointer &DP) {`
`286`	`286`	`Group.Casts[BB] = ASC;`
`287`	`287`	`}`
`288`	`288`	`Group.Successor = DP.Phi->getParent();`
`289`		`- PointerGroups.push_back(std::move(Group));`
	`289`	`+ PointerGroups.push_back(Group);`
`290`	`290`	`return true;`
`291`	`291`	`}`
`292`	`292`
Original file line number	Diff line number	Diff line change
`@@ -606,8 +606,8 @@ static bool isEntryPoint(const CodeGenContext ctx, const llvm::Function F) {`
`606`	`606`	`return false;`
`607`	`607`	`}`
`608`	`608`
`609`		`- const auto &FuncMD = ctx->getModuleMetaData()->FuncMD;`
`610`		`- const auto &FuncInfo = FuncMD.find(const_cast<llvm::Function *>(F));`
	`609`	`+ auto &FuncMD = ctx->getModuleMetaData()->FuncMD;`
	`610`	`+ auto FuncInfo = FuncMD.find(const_cast<llvm::Function *>(F));`
`611`	`611`	`if (FuncInfo == FuncMD.end()) {`
`612`	`612`	`return false;`
`613`	`613`	`}`
Original file line number	Diff line number	Diff line change
`@@ -260,7 +260,7 @@ void GASRetValuePropagator::updateMetadata(Function oldFunc, Function newFunc)`
`260`	`260`	`if (loc != FuncMD.end()) {`
`261`	`261`	`auto funcInfo = loc->second;`
`262`	`262`	`FuncMD.erase(oldFunc);`
`263`		`- FuncMD[newFunc] = std::move(funcInfo);`
	`263`	`+ FuncMD[newFunc] = funcInfo;`
`264`	`264`	`}`
`265`	`265`
`266`	`266`	`m_mdUtils->save(m_module->getContext());`
Original file line number	Diff line number	Diff line change
`@@ -291,15 +291,15 @@ class DbgDecoder {`
`291`	`291`	`for (unsigned int j = 0; j != count; j++) {`
`292`	`292`	`uint32_t cisaOffset = read<uint32_t>(dbg);`
`293`	`293`	`uint32_t genOffset = read<uint32_t>(dbg);`
`294`		`- f.CISAOffsetMap.emplace_back(cisaOffset, f.relocOffset + genOffset);`
	`294`	`+ f.CISAOffsetMap.push_back(std::make_pair(cisaOffset, f.relocOffset + genOffset));`
`295`	`295`	`}`
`296`	`296`
`297`	`297`	`// cisa index map`
`298`	`298`	`count = read<uint32_t>(dbg);`
`299`	`299`	`for (unsigned int j = 0; j != count; j++) {`
`300`	`300`	`uint32_t cisaIndex = read<uint32_t>(dbg);`
`301`	`301`	`uint32_t genOffset = read<uint32_t>(dbg);`
`302`		`- f.CISAIndexMap.emplace_back(cisaIndex, f.relocOffset + genOffset);`
	`302`	`+ f.CISAIndexMap.push_back(std::make_pair(cisaIndex, f.relocOffset + genOffset));`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`// var info`
`@@ -314,10 +314,10 @@ class DbgDecoder {`
`314`	`314`	`auto countLRs = read<uint16_t>(dbg);`
`315`	`315`	`for (unsigned int k = 0; k != countLRs; k++) {`
`316`	`316`	`LiveIntervalsVISA lv = readLiveIntervalsVISA();`
`317`		`- v.lrs.push_back(std::move(lv));`
	`317`	`+ v.lrs.push_back(lv);`
`318`	`318`	`}`
`319`	`319`
`320`		`- f.Vars.push_back(std::move(v));`
	`320`	`+ f.Vars.push_back(v);`
`321`	`321`	`}`
`322`	`322`
`323`	`323`	`// subroutines`
`@@ -335,7 +335,7 @@ class DbgDecoder {`
`335`	`335`	`LiveIntervalsVISA lv = readLiveIntervalsVISA();`
`336`	`336`	`sub.retval.push_back(lv);`
`337`	`337`	`}`
`338`		`- f.subs.push_back(std::move(sub));`
	`338`	`+ f.subs.push_back(sub);`
`339`	`339`	`}`
`340`	`340`
`341`	`341`	`// call frame information`
`@@ -346,23 +346,23 @@ class DbgDecoder {`
`346`	`346`	`for (unsigned int j = 0; j != count; j++) {`
`347`	`347`	`LiveIntervalGenISA lv = readLiveIntervalGenISA();`
`348`	`348`	`;`
`349`		`- f.cfi.befp.push_back(std::move(lv));`
	`349`	`+ f.cfi.befp.push_back(lv);`
`350`	`350`	`}`
`351`	`351`	`}`
`352`	`352`	`f.cfi.callerbefpValid = (bool)read<uint8_t>(dbg);`
`353`	`353`	`if (f.cfi.callerbefpValid) {`
`354`	`354`	`count = read<uint16_t>(dbg);`
`355`	`355`	`for (unsigned int j = 0; j != count; j++) {`
`356`	`356`	`LiveIntervalGenISA lv = readLiveIntervalGenISA();`
`357`		`- f.cfi.callerbefp.push_back(std::move(lv));`
	`357`	`+ f.cfi.callerbefp.push_back(lv);`
`358`	`358`	`}`
`359`	`359`	`}`
`360`	`360`	`f.cfi.retAddrValid = (bool)read<uint8_t>(dbg);`
`361`	`361`	`if (f.cfi.retAddrValid) {`
`362`	`362`	`count = read<uint16_t>(dbg);`
`363`	`363`	`for (unsigned int j = 0; j != count; j++) {`
`364`	`364`	`LiveIntervalGenISA lv = readLiveIntervalGenISA();`
`365`		`- f.cfi.retAddr.push_back(std::move(lv));`
	`365`	`+ f.cfi.retAddr.push_back(lv);`
`366`	`366`	`}`
`367`	`367`	`}`
`368`	`368`	`f.cfi.CEOffsetFromFPOff = read<uint16_t>(dbg);`
`@@ -374,7 +374,7 @@ class DbgDecoder {`
`374`	`374`	`phyRegSave.numEntries = read<uint16_t>(dbg);`
`375`	`375`	`for (unsigned int k = 0; k != phyRegSave.numEntries; k++)`
`376`	`376`	`phyRegSave.data.push_back(readRegInfoMapping());`
`377`		`- f.cfi.calleeSaveEntry.push_back(std::move(phyRegSave));`
	`377`	`+ f.cfi.calleeSaveEntry.push_back(phyRegSave);`
`378`	`378`	`}`
`379`	`379`
`380`	`380`	`f.cfi.numCallerSaveEntries = read<uint32_t>(dbg);`
`@@ -384,10 +384,10 @@ class DbgDecoder {`
`384`	`384`	`phyRegSave.numEntries = read<uint16_t>(dbg);`
`385`	`385`	`for (unsigned int k = 0; k != phyRegSave.numEntries; k++)`
`386`	`386`	`phyRegSave.data.push_back(readRegInfoMapping());`
`387`		`- f.cfi.callerSaveEntry.push_back(std::move(phyRegSave));`
	`387`	`+ f.cfi.callerSaveEntry.push_back(phyRegSave);`
`388`	`388`	`}`
`389`	`389`
`390`		`- compiledObjs.push_back(std::move(f));`
	`390`	`+ compiledObjs.push_back(f);`
`391`	`391`	`}`
`392`	`392`	`}`
`393`	`393`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ MoveEntryPointModuleToTheEnd(llvm::ArrayRef<IGC::VLD::SPVTranslationPair> InputM`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`if (HasEntryPointModule) {`
`192`		`- RetPairs.push_back(std::move(EntryPointPair));`
	`192`	`+ RetPairs.push_back(EntryPointPair);`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`return RetPairs;`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ std::vector<std::string> SPIRVParser::getEntryPointNames(const StringRef binary)`
`37`	`37`	`while (binary.data()[(offsetInWords + 3) * 4 + nameLength])`
`38`	`38`	`nameLength++;`
`39`	`39`	`std::string name = binary.substr((offsetInWords + 3) * 4, nameLength).str();`
`40`		`- entryPointNames.push_back(std::move(name));`
	`40`	`+ entryPointNames.push_back(name);`
`41`	`41`	`}`
`42`	`42`	`offsetInWords += opWordsCount; // skip instruction`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ template <typename T> void readNode(std::vector<T> &vec, MDNode *node) {`
`325`	`325`	`for (unsigned k = 1; k < node->getNumOperands(); k++) {`
`326`	`326`	`T vecEle;`
`327`	`327`	`readNode(vecEle, cast<MDNode>(node->getOperand(k)));`
`328`		`- vec.push_back(std::move(vecEle));`
	`328`	`+ vec.push_back(vecEle);`
`329`	`329`	`}`
`330`	`330`	`return;`
`331`	`331`	`}`
`@@ -380,7 +380,7 @@ template <typename Key, typename Value> void readNode(std::map<Key, Value> &keyM`
`380`	`380`	`std::pair<Key, Value> p;`
`381`	`381`	`readNode(p.first, cast<MDNode>(node->getOperand(k++)));`
`382`	`382`	`readNode(p.second, cast<MDNode>(node->getOperand(k)));`
`383`		`- keyMD.insert(std::move(p));`
	`383`	`+ keyMD.insert(p);`
`384`	`384`	`}`
`385`	`385`	`return;`
`386`	`386`	`}`
`@@ -390,7 +390,7 @@ template <typename Key, typename Value> void readNode(MapVector<Key, Value> &key`
`390`	`390`	`std::pair<Key, Value> p;`
`391`	`391`	`readNode(p.first, cast<MDNode>(node->getOperand(k++)));`
`392`	`392`	`readNode(p.second, cast<MDNode>(node->getOperand(k)));`
`393`		`- keyMD.insert(std::move(p));`
	`393`	`+ keyMD.insert(p);`
`394`	`394`	`}`
`395`	`395`	`return;`
`396`	`396`	`}`
`@@ -399,7 +399,7 @@ template <typename Key> void readNode(std::set<Key> &keyMD, MDNode *node) {`
`399`	`399`	`for (unsigned k = 1; k < node->getNumOperands(); k++) {`
`400`	`400`	`Key key;`
`401`	`401`	`readNode(key, cast<MDNode>(node->getOperand(k)));`
`402`		`- keyMD.insert(std::move(key));`
	`402`	`+ keyMD.insert(key);`
`403`	`403`	`}`
`404`	`404`	`return;`
`405`	`405`	`}`
`@@ -408,7 +408,7 @@ template <typename Key> void readNode(SetVector<Key> &keyMD, MDNode *node) {`
`408`	`408`	`for (unsigned k = 1; k < node->getNumOperands(); k++) {`
`409`	`409`	`Key key;`
`410`	`410`	`readNode(key, cast<MDNode>(node->getOperand(k)));`
`411`		`- keyMD.insert(std::move(key));`
	`411`	`+ keyMD.insert(key);`
`412`	`412`	`}`
`413`	`413`	`return;`
`414`	`414`	`}`
Original file line number	Diff line number	Diff line change
`@@ -667,7 +667,7 @@ static void ParseEntryPoint(llvm::StringRef line, std::vector<EntryPoint> &entry`
`667`	`667`	`auto [token, RHS] = vString.split(',');`
`668`	`668`	`EntryPoint entry_point{};`
`669`	`669`	`entry_point.entry_point_name = token.str();`
`670`		`- entry_points.push_back(std::move(entry_point));`
	`670`	`+ entry_points.push_back(entry_point);`
`671`	`671`	`vString = RHS;`
`672`	`672`	`} while (!vString.empty());`
`673`	`673`	`}`