Update integer casting for LLVM 14 codebase

Artem Gindinson · igcbot · commit 373d8b042d2d · 2022-06-22T12:30:48.000+02:00
Make sure all possible warnings are silenced whenever LLVM 14 is enabled.
diff --git a/IGC/Compiler/CISACodeGen/CShader.cpp b/IGC/Compiler/CISACodeGen/CShader.cpp
@@ -1395,7 +1395,7 @@ uint CShader::GetNbVectorElementAndMask(llvm::Value* val, uint32_t& mask)
             uint32_t elts = VTy ? int_cast<uint32_t>(VTy->getNumElements()) : 1;
             uint32_t totalBytes = eltBytes * elts;
 
-            unsigned align = LD->getAlignment();
+            unsigned align = (unsigned)LD->getAlignment();
 
             uint bufferIndex = 0;
             bool directIndexing = false;
diff --git a/IGC/Compiler/CISACodeGen/ConstantCoalescing.cpp b/IGC/Compiler/CISACodeGen/ConstantCoalescing.cpp
@@ -1165,7 +1165,7 @@ uint ConstantCoalescing::GetAlignment(Instruction* load) const
 
     if (isa<LoadInst>(load))
     {
-        alignment = cast<LoadInst>(load)->getAlignment();
+        alignment = (uint)cast<LoadInst>(load)->getAlignment();
     }
     else
     {
diff --git a/IGC/Compiler/CISACodeGen/EmitVISAPass.cpp b/IGC/Compiler/CISACodeGen/EmitVISAPass.cpp
@@ -11542,7 +11542,7 @@ void EmitPass::emitLoad(LoadInst* inst, Value* offset, ConstantInt* immOffset)
             immOffset,
             inst->getType(),
             cacheOpts,
-            inst->getAlignment());
+            (uint32_t)inst->getAlignment());
         return;
     }
     emitVectorLoad(inst, offset, immOffset);
@@ -12697,7 +12697,7 @@ void EmitPass::emitStore(StoreInst* inst, Value* varOffset, ConstantInt* immOffs
             immOffset,
             inst->getValueOperand(),
             cacheOpts,
-            inst->getAlignment());
+            (uint32_t)inst->getAlignment());
         return;
     }
     emitVectorStore(inst, varOffset, immOffset);
@@ -17960,7 +17960,7 @@ void EmitPass::emitVectorLoad(LoadInst* inst, Value* offset, ConstantInt* immOff
     IGC_ASSERT_MESSAGE(!(destUniform && !srcUniform),
         "If ld's dest is uniform, ld's src must be uniform");
 
-    unsigned align = inst->getAlignment();
+    unsigned align = (unsigned)inst->getAlignment();
     VISA_Type destType = m_destination->GetType();
     uint32_t width = numLanes(m_currShader->m_SIMDSize);
     uint bufferIndex = 0;
@@ -18482,7 +18482,7 @@ void EmitPass::emitVectorStore(StoreInst* inst, Value* offset, ConstantInt* immO
 
     uint32_t elts = VTy ? int_cast<uint32_t>(VTy->getNumElements()) : 1;
     uint32_t totalBytes = elts * eltBytes;
-    unsigned align = inst->getAlignment();
+    unsigned align = (unsigned)inst->getAlignment();
     CVariable* storedVar = GetSymbol(storedVal);
     unsigned int width = numLanes(m_currShader->m_SIMDSize);
 
diff --git a/IGC/Compiler/CISACodeGen/Emu64OpsPass.cpp b/IGC/Compiler/CISACodeGen/Emu64OpsPass.cpp
@@ -124,16 +124,16 @@ namespace {
         void setExpandedValues(Value* V, Value* Lo, Value* Hi);
 
         unsigned getAlignment(LoadInst* LD) const {
-            unsigned Align = LD->getAlignment();
+            unsigned Align = (unsigned)LD->getAlignment();
             if (Align == 0)
-                Align = DL->getABITypeAlignment(LD->getType());
+                Align = (unsigned)DL->getABITypeAlignment(LD->getType());
             return Align;
         }
 
         unsigned getAlignment(StoreInst* ST) const {
-            unsigned Align = ST->getAlignment();
+            unsigned Align = (unsigned)ST->getAlignment();
             if (Align == 0)
-                Align = DL->getABITypeAlignment(ST->getType());
+                Align = (unsigned)DL->getABITypeAlignment(ST->getType());
             return Align;
         }
 
diff --git a/IGC/Compiler/CISACodeGen/PartialEmuI64OpsPass.cpp b/IGC/Compiler/CISACodeGen/PartialEmuI64OpsPass.cpp
@@ -125,16 +125,16 @@ namespace {
         bool valueNotStored(Value* V);
 
         unsigned getAlignment(LoadInst* LD) const {
-            unsigned Align = LD->getAlignment();
+            unsigned Align = (unsigned)LD->getAlignment();
             if (Align == 0)
-                Align = DL->getABITypeAlignment(LD->getType());
+                Align = (unsigned)DL->getABITypeAlignment(LD->getType());
             return Align;
         }
 
         unsigned getAlignment(StoreInst* ST) const {
-            unsigned Align = ST->getAlignment();
+            unsigned Align = (unsigned)ST->getAlignment();
             if (Align == 0)
-                Align = DL->getABITypeAlignment(ST->getType());
+                Align = (unsigned)DL->getABITypeAlignment(ST->getType());
             return Align;
         }
 
diff --git a/IGC/Compiler/CISACodeGen/VectorPreProcess.cpp b/IGC/Compiler/CISACodeGen/VectorPreProcess.cpp
@@ -115,7 +115,7 @@ namespace
         }
         unsigned int getAlignment() const
         {
-            return isa<LoadInst>(m_inst) ? getLoad()->getAlignment() : getLdRaw()->getAlignment();
+            return (unsigned)(isa<LoadInst>(m_inst) ? getLoad()->getAlignment() : getLdRaw()->getAlignment());
         }
         void setAlignment(unsigned int alignment)
         {
@@ -220,7 +220,7 @@ namespace
         }
         unsigned int getAlignment() const
         {
-            return isa<StoreInst>(m_inst) ? getStore()->getAlignment() : getStoreRaw()->getAlignment();
+            return (unsigned)(isa<StoreInst>(m_inst) ? getStore()->getAlignment() : getStoreRaw()->getAlignment());
         }
         void setAlignment(unsigned int alignment)
         {
diff --git a/IGC/Compiler/CISACodeGen/VectorProcess.cpp b/IGC/Compiler/CISACodeGen/VectorProcess.cpp
@@ -284,11 +284,11 @@ bool VectorProcess::reLayoutLoadStore(Instruction* Inst)
         uint32_t align;
         if (LI)
         {
-            align = LI->getAlignment();
+            align = (uint32_t)LI->getAlignment();
         }
         else if (SI)
         {
-            align = SI->getAlignment();
+            align = (uint32_t)SI->getAlignment();
         }
         else
         {
diff --git a/IGC/Compiler/CISACodeGen/helper.cpp b/IGC/Compiler/CISACodeGen/helper.cpp
@@ -359,9 +359,9 @@ namespace IGC
                 GenISAIntrinsic::GenISA_ldraw_indexed,
             tys);
 
-        unsigned alignment = inst->getAlignment();
+        unsigned alignment = (unsigned)inst->getAlignment();
         if (alignment == 0)
-            alignment = DL.getABITypeAlignment(inst->getType());
+            alignment = (unsigned)DL.getABITypeAlignment(inst->getType());
 
         IRBuilder<> builder(inst);
 
@@ -406,9 +406,9 @@ namespace IGC
             func = GenISAIntrinsic::getDeclaration(module, llvm::GenISAIntrinsic::GenISA_storeraw_indexed, types);
         }
         IRBuilder<> builder(inst);
-        unsigned alignment = inst->getAlignment();
+        unsigned alignment = (unsigned)inst->getAlignment();
         if (alignment == 0)
-            alignment = DL.getABITypeAlignment(storeVal->getType());
+            alignment = (unsigned)DL.getABITypeAlignment(storeVal->getType());
         Value* attr[] =
         {
             bufPtr,
diff --git a/IGC/Compiler/FixResourcePtr.cpp b/IGC/Compiler/FixResourcePtr.cpp
@@ -249,7 +249,7 @@ Value* FixResourcePtr::CreateLoadIntrinsic(LoadInst* inst, Instruction* bufPtr,
     unsigned alignment = (inst->getType()->getScalarSizeInBits() / 8);
     if (inst->getAlignment() > 0)
     {
-        alignment = inst->getAlignment();
+        alignment = (unsigned)inst->getAlignment();
     }
 
     Value* attr[] =
diff --git a/IGC/Compiler/Legalizer/TypeLegalizer.h b/IGC/Compiler/Legalizer/TypeLegalizer.h
@@ -578,17 +578,17 @@ namespace IGC {
 
         template<> inline
             unsigned TypeLegalizer::getAlignment(LoadInst* Ld) const {
-            unsigned Align = Ld->getAlignment();
+            unsigned Align = (unsigned)Ld->getAlignment();
             if (Align == 0)
-                Align = DL->getABITypeAlignment(Ld->getType());
+                Align = (unsigned)DL->getABITypeAlignment(Ld->getType());
             return Align;
         }
 
         template<> inline
             unsigned TypeLegalizer::getAlignment(StoreInst* St) const {
-            unsigned Align = St->getAlignment();
+            unsigned Align = (unsigned)St->getAlignment();
             if (Align == 0)
-                Align = DL->getABITypeAlignment(St->getValueOperand()->getType());
+                Align = (unsigned)DL->getABITypeAlignment(St->getValueOperand()->getType());
             return Align;
         }
 
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/AlignmentAnalysis/AlignmentAnalysis.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/AlignmentAnalysis/AlignmentAnalysis.cpp
@@ -101,11 +101,7 @@ auto AlignmentAnalysis::getConstantAlignment(uint64_t C) const
     {
         return Value::MaximumAlignment;
     }
-#if LLVM_VERSION_MAJOR >= 14
-    return iSTD::Min(Value::MaximumAlignment, 1UL << llvm::countTrailingZeros(C));
-#else
-    return iSTD::Min(Value::MaximumAlignment, 1U << llvm::countTrailingZeros(C));
-#endif
+    return iSTD::Min(Value::MaximumAlignment, (alignment_t)1U << (alignment_t)llvm::countTrailingZeros(C));
 }
 
 auto AlignmentAnalysis::getAlignValue(Value* V) const
@@ -181,7 +177,7 @@ auto AlignmentAnalysis::getAlignValue(Value* V) const
 bool AlignmentAnalysis::processInstruction(llvm::Instruction* I)
 {
     // Get the currently known alignment of I.
-    unsigned int currAlign = getAlignValue(I);
+    unsigned int currAlign = (unsigned)getAlignValue(I);
 
     // Compute the instruction's alignment
     // using the alignment of the arguments.
@@ -224,13 +220,13 @@ unsigned int AlignmentAnalysis::visitInstruction(Instruction& I)
 unsigned int AlignmentAnalysis::visitAllocaInst(AllocaInst& I)
 {
     // Return the alignment of the alloca, which ought to be correct
-    unsigned int newAlign = I.getAlignment();
+    unsigned int newAlign = (unsigned)I.getAlignment();
 
     // If the alloca uses the default alignment, pull it from the datalayout
     if (!newAlign)
     {
         Type* allocaType = I.getType();
-        newAlign = m_DL->getABITypeAlignment(allocaType->getPointerElementType());
+        newAlign = (unsigned)m_DL->getABITypeAlignment(allocaType->getPointerElementType());
     }
 
     return newAlign;
@@ -243,7 +239,7 @@ unsigned int AlignmentAnalysis::visitSelectInst(SelectInst& I)
 
     // In general this should be the GCD, but because we assume we are always aligned on
     // powers of 2, the GCD is the minimum.
-    return iSTD::Min(getAlignValue(srcTrue), getAlignValue(srcFalse));
+    return iSTD::Min((unsigned)getAlignValue(srcTrue), (unsigned)getAlignValue(srcFalse));
 }
 
 unsigned int AlignmentAnalysis::visitPHINode(PHINode& I)
@@ -259,7 +255,7 @@ unsigned int AlignmentAnalysis::visitPHINode(PHINode& I)
         newAlign = iSTD::Min(newAlign, getAlignValue(op));
     }
 
-    return newAlign;
+    return (unsigned)newAlign;
 }
 
 void AlignmentAnalysis::SetInstAlignment(llvm::Instruction& I)
@@ -316,7 +312,7 @@ unsigned int AlignmentAnalysis::visitAdd(BinaryOperator& I)
     Value* op0 = I.getOperand(0);
     Value* op1 = I.getOperand(1);
 
-    return iSTD::Min(getAlignValue(op0), getAlignValue(op1));
+    return iSTD::Min((unsigned)getAlignValue(op0), (unsigned)getAlignValue(op1));
 }
 
 unsigned int AlignmentAnalysis::visitMul(BinaryOperator& I)
@@ -326,8 +322,8 @@ unsigned int AlignmentAnalysis::visitMul(BinaryOperator& I)
     Value* op0 = I.getOperand(0);
     Value* op1 = I.getOperand(1);
 
-    return iSTD::Min(Value::MaximumAlignment,
-        getAlignValue(op0) * getAlignValue(op1));
+    return iSTD::Min((unsigned)Value::MaximumAlignment,
+        (unsigned)(getAlignValue(op0) * getAlignValue(op1)));
 }
 
 unsigned int AlignmentAnalysis::visitShl(BinaryOperator& I)
@@ -340,12 +336,12 @@ unsigned int AlignmentAnalysis::visitShl(BinaryOperator& I)
 
     if (ConstantInt * constOp1 = dyn_cast<ConstantInt>(op1))
     {
-        return iSTD::Min(Value::MaximumAlignment,
-            getAlignValue(op0) << constOp1->getZExtValue());
+        return iSTD::Min((unsigned)Value::MaximumAlignment,
+            (unsigned)getAlignValue(op0) << constOp1->getZExtValue());
     }
     else
     {
-        return getAlignValue(op0);
+        return (unsigned)getAlignValue(op0);
     }
 }
 
@@ -357,14 +353,14 @@ unsigned int AlignmentAnalysis::visitAnd(BinaryOperator& I)
     // If one of the operands has trailing zeroes up to some point,
     // then so will the result. So, the alignment is at least the maximum
     // of the operands.
-    return iSTD::Max(getAlignValue(op0),
-        getAlignValue(op1));
+    return iSTD::Max((unsigned)getAlignValue(op0),
+        (unsigned)getAlignValue(op1));
 }
 
 unsigned int AlignmentAnalysis::visitGetElementPtrInst(GetElementPtrInst& I)
 {
     // The alignment can never be better than the alignment of the base pointer
-    unsigned int newAlign = getAlignValue(I.getPointerOperand());
+    unsigned int newAlign = (unsigned)getAlignValue(I.getPointerOperand());
 
     Type* Ty = I.getPointerOperand()->getType()->getScalarType();
     gep_type_iterator GTI = gep_type_begin(&I);
@@ -381,7 +377,7 @@ unsigned int AlignmentAnalysis::visitGetElementPtrInst(GetElementPtrInst& I)
         {
             Ty = GTI.getIndexedType();
             unsigned int multiplier = int_cast<unsigned int>(m_DL->getTypeAllocSize(Ty));
-            offset = multiplier * getAlignValue(*op);
+            offset = multiplier * int_cast<unsigned int>(getAlignValue(*op));
         }
 
         // It's possible offset is not a power of 2, because struct fields
@@ -390,7 +386,7 @@ unsigned int AlignmentAnalysis::visitGetElementPtrInst(GetElementPtrInst& I)
         // highest power of 2 that divides both.
 
         // x | y has trailing 0s exactly where both x and y have trailing 0s.
-        newAlign = getConstantAlignment(newAlign | offset);
+        newAlign = (unsigned)getConstantAlignment(newAlign | offset);
     }
 
     return newAlign;
@@ -401,32 +397,32 @@ unsigned int AlignmentAnalysis::visitGetElementPtrInst(GetElementPtrInst& I)
 // but this doesn't seem important enough.
 unsigned int AlignmentAnalysis::visitBitCastInst(BitCastInst& I)
 {
-    return getAlignValue(I.getOperand(0));
+    return (unsigned)getAlignValue(I.getOperand(0));
 }
 
 unsigned int AlignmentAnalysis::visitPtrToIntInst(PtrToIntInst& I)
 {
-    return getAlignValue(I.getOperand(0));
+    return (unsigned)getAlignValue(I.getOperand(0));
 }
 
 unsigned int AlignmentAnalysis::visitIntToPtrInst(IntToPtrInst& I)
 {
-    return getAlignValue(I.getOperand(0));
+    return (unsigned)getAlignValue(I.getOperand(0));
 }
 
 unsigned int AlignmentAnalysis::visitTruncInst(TruncInst& I)
 {
-    return getAlignValue(I.getOperand(0));
+    return (unsigned)getAlignValue(I.getOperand(0));
 }
 
 unsigned int AlignmentAnalysis::visitZExtInst(ZExtInst& I)
 {
-    return getAlignValue(I.getOperand(0));
+    return (unsigned)getAlignValue(I.getOperand(0));
 }
 
 unsigned int AlignmentAnalysis::visitSExtInst(SExtInst& I)
 {
-    return getAlignValue(I.getOperand(0));
+    return (unsigned)getAlignValue(I.getOperand(0));
 }
 
 unsigned int AlignmentAnalysis::visitCallInst(CallInst& I)
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp
@@ -2274,7 +2274,7 @@ namespace //Anonymous
             }
         }
 
-        auto align = _DL->getPrefTypeAlignment(destPtr->getType()->getPointerElementType());
+        unsigned align = (unsigned)_DL->getPrefTypeAlignment(destPtr->getType()->getPointerElementType());
 
         return (byVal && KindQuery::isStructType(typeToSelect))
             ? CreateMemCpy(destPtr, source, align)
@@ -2364,7 +2364,7 @@ namespace //Anonymous
             }
             align = elemAlign > align ? elemAlign : align;
         }
-        return align;
+        return (unsigned)align;
     }
 
     llvm::CallInst* BlockInvoke::EmitBlockInvokeCall(IGCLLVM::IRBuilder<>& builder, llvm::ArrayRef<llvm::Argument*> captures, llvm::ArrayRef<llvm::Argument*> tailingArgs) const
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/KernelArgs.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/KernelArgs.cpp
@@ -107,7 +107,7 @@ unsigned int KernelArg::calcAlignment(const Argument* arg, const DataLayout* DL)
         typeToAlign = cast<PointerType>(typeToAlign)->getElementType();
     }
 
-    return DL->getABITypeAlignment(typeToAlign);
+    return (unsigned)DL->getABITypeAlignment(typeToAlign);
 }
 
 unsigned int KernelArg::calcElemAllocateSize(const Argument* arg, const DataLayout* DL) const
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryBufferAnalysis.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryBufferAnalysis.cpp
@@ -79,9 +79,9 @@ void PrivateMemoryBufferAnalysis::visitAllocaInst(AllocaInst& AI)
 
     m_privateInfoMap[pFunc].m_allocaInsts.push_back(&AI);
 
-    unsigned int alignment = AI.getAlignment();
+    unsigned int alignment = (unsigned)AI.getAlignment();
     if (alignment == 0) {
-        alignment = m_DL->getABITypeAlignment(AI.getAllocatedType());
+        alignment = (unsigned)m_DL->getABITypeAlignment(AI.getAllocatedType());
     }
 
     // Update max alignment
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantAnalysis.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantAnalysis.cpp
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStateful/StatelessToStateful.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStateful/StatelessToStateful.cpp
diff --git a/IGC/WrapperLLVM/include/llvmWrapper/Support/Alignment.h b/IGC/WrapperLLVM/include/llvmWrapper/Support/Alignment.h

Original file line number	Diff line number	Diff line change
`@@ -1165,7 +1165,7 @@ uint ConstantCoalescing::GetAlignment(Instruction* load) const`
`1165`	`1165`
`1166`	`1166`	`if (isa<LoadInst>(load))`
`1167`	`1167`	`{`
`1168`		`- alignment = cast<LoadInst>(load)->getAlignment();`
	`1168`	`+ alignment = (uint)cast<LoadInst>(load)->getAlignment();`
`1169`	`1169`	`}`
`1170`	`1170`	`else`
`1171`	`1171`	`{`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ namespace`
`115`	`115`	`}`
`116`	`116`	`unsigned int getAlignment() const`
`117`	`117`	`{`
`118`		`- return isa<LoadInst>(m_inst) ? getLoad()->getAlignment() : getLdRaw()->getAlignment();`
	`118`	`+ return (unsigned)(isa<LoadInst>(m_inst) ? getLoad()->getAlignment() : getLdRaw()->getAlignment());`
`119`	`119`	`}`
`120`	`120`	`void setAlignment(unsigned int alignment)`
`121`	`121`	`{`
`@@ -220,7 +220,7 @@ namespace`
`220`	`220`	`}`
`221`	`221`	`unsigned int getAlignment() const`
`222`	`222`	`{`
`223`		`- return isa<StoreInst>(m_inst) ? getStore()->getAlignment() : getStoreRaw()->getAlignment();`
	`223`	`+ return (unsigned)(isa<StoreInst>(m_inst) ? getStore()->getAlignment() : getStoreRaw()->getAlignment());`
`224`	`224`	`}`
`225`	`225`	`void setAlignment(unsigned int alignment)`
`226`	`226`	`{`
Original file line number	Diff line number	Diff line change
`@@ -284,11 +284,11 @@ bool VectorProcess::reLayoutLoadStore(Instruction* Inst)`
`284`	`284`	`uint32_t align;`
`285`	`285`	`if (LI)`
`286`	`286`	`{`
`287`		`- align = LI->getAlignment();`
	`287`	`+ align = (uint32_t)LI->getAlignment();`
`288`	`288`	`}`
`289`	`289`	`else if (SI)`
`290`	`290`	`{`
`291`		`- align = SI->getAlignment();`
	`291`	`+ align = (uint32_t)SI->getAlignment();`
`292`	`292`	`}`
`293`	`293`	`else`
`294`	`294`	`{`
Original file line number	Diff line number	Diff line change
`@@ -249,7 +249,7 @@ Value* FixResourcePtr::CreateLoadIntrinsic(LoadInst* inst, Instruction* bufPtr,`
`249`	`249`	`unsigned alignment = (inst->getType()->getScalarSizeInBits() / 8);`
`250`	`250`	`if (inst->getAlignment() > 0)`
`251`	`251`	`{`
`252`		`- alignment = inst->getAlignment();`
	`252`	`+ alignment = (unsigned)inst->getAlignment();`
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`Value* attr[] =`