Handle negative numbers ext after constant sinking

Handle negative numbers ext after constant sinking

Author: skarczew

IGC/Compiler/CISACodeGen/PushAnalysis.cpp

@@ -172,8 +172,8 @@ bool PushAnalysis::IsStatelessCBLoad(llvm::Instruction *inst, int &pushableAddre
     if (pAdd && pAdd->getOpcode() == llvm::Instruction::Add) {
       GetPotentialPushableAddresses(pAdd->getOperand(0));
       GetPotentialPushableAddresses(pAdd->getOperand(1));
-    } else if (isa<ZExtInst>(pAddress)) {
-      GetPotentialPushableAddresses(cast<ZExtInst>(pAddress)->getOperand(0));
+    } else if (isa<ZExtInst>(pAddress) || isa<SExtInst>(pAddress)) {
+      GetPotentialPushableAddresses(cast<Instruction>(pAddress)->getOperand(0));
     } else if (isa<ConstantInt>(pAddress)) {
       ConstantInt *pConst = cast<ConstantInt>(pAddress);
       offset += pConst->getZExtValue();

IGC/Compiler/Optimizer/SinkPointerConstAdd.cpp

@@ -41,7 +41,8 @@ class SinkPointerConstAddPass : public llvm::FunctionPass {
   static char ID;
 
 private:
-  bool getConstantOffset(llvm::Value *value, int &offset);
+  bool getConstantOffset(llvm::Value *value, std::vector<llvm::Instruction *> &zexts, int &offset);
+  void zextToSext(std::vector<llvm::Instruction *> &zexts);
 };
 
 #define PASS_FLAG "igc-sink-ptr-const-add"
@@ -50,7 +51,8 @@ class SinkPointerConstAddPass : public llvm::FunctionPass {
 #define PASS_ANALYSIS false
 IGC_INITIALIZE_PASS(SinkPointerConstAddPass, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)
 
-bool SinkPointerConstAddPass::getConstantOffset(llvm::Value *value, int &offset) {
+bool SinkPointerConstAddPass::getConstantOffset(llvm::Value *value, std::vector<llvm::Instruction *> &zexts,
+                                                int &offset) {
   // Recursively search for constant add operations - this will stop after the first const add found,
   // and should be called repeatedly until no more const adds can be sunk.
 
@@ -61,11 +63,15 @@ bool SinkPointerConstAddPass::getConstantOffset(llvm::Value *value, int &offset)
   if (llvm::Instruction *instr = llvm::dyn_cast<llvm::Instruction>(value)) {
     if (instr->getOpcode() == llvm::Instruction::Trunc || instr->getOpcode() == llvm::Instruction::ZExt ||
         instr->getOpcode() == llvm::Instruction::SExt) {
+      // Collect zext instructions for later processing
+      if (instr->getOpcode() == llvm::Instruction::ZExt) {
+        zexts.push_back(instr);
+      }
       // Skip cast instructions
       llvm::Instruction *op = llvm::dyn_cast<llvm::Instruction>(instr->getOperand(0));
       // This is a simple pass, only sink within the same basic block
       if (op && instr->getParent() == op->getParent()) {
-        return getConstantOffset(instr->getOperand(0), offset);
+        return getConstantOffset(instr->getOperand(0), zexts, offset);
       } else {
         return false;
       }
@@ -89,8 +95,8 @@ bool SinkPointerConstAddPass::getConstantOffset(llvm::Value *value, int &offset)
         llvm::Instruction *op0 = llvm::dyn_cast<llvm::Instruction>(instr->getOperand(0));
         llvm::Instruction *op1 = llvm::dyn_cast<llvm::Instruction>(instr->getOperand(1));
         // This is a simple pass, only sink within the same basic block
-        return (op0 && instr->getParent() == op0->getParent() && getConstantOffset(op0, offset)) ? true
-               : (op1 && instr->getParent() == op1->getParent()) ? getConstantOffset(op1, offset)
+        return (op0 && instr->getParent() == op0->getParent() && getConstantOffset(op0, zexts, offset)) ? true
+               : (op1 && instr->getParent() == op1->getParent()) ? getConstantOffset(op1, zexts, offset)
                                                                  : false;
       }
     }
@@ -99,6 +105,19 @@ bool SinkPointerConstAddPass::getConstantOffset(llvm::Value *value, int &offset)
   return false;
 }
 
+void SinkPointerConstAddPass::zextToSext(std::vector<llvm::Instruction *> &zexts) {
+  // Remove duplicates
+  std::sort(zexts.begin(), zexts.end());
+  zexts.erase(std::unique(zexts.begin(), zexts.end()), zexts.end());
+  // Convert zext instructions to sext instructions
+  for (auto &zext : zexts) {
+    llvm::IRBuilder<> builder(zext);
+    llvm::Value *sext = builder.CreateSExt(zext->getOperand(0), zext->getType());
+    zext->replaceAllUsesWith(sext);
+    zext->eraseFromParent();
+  }
+}
+
 bool SinkPointerConstAddPass::runOnFunction(llvm::Function &F) {
   bool changed = false;
   std::vector<llvm::IntToPtrInst *> intToPtrInsts;
@@ -115,11 +134,20 @@ bool SinkPointerConstAddPass::runOnFunction(llvm::Function &F) {
 
   for (auto &intrinsic : intToPtrInsts) {
     int offset = 0;
+    bool localChanged = false;
+    std::vector<llvm::Instruction *> zexts;
     // Keep sinking constant adds until no more can be sunk
-    while (getConstantOffset(intrinsic->getOperand(0), offset)) {
+    while (getConstantOffset(intrinsic->getOperand(0), zexts, offset)) {
+      localChanged = true;
       changed = true;
     }
 
+    if (localChanged) {
+      // In some cases, sinking constant add may introduce negative values in pointer calculations.
+      // Convert affected zext instructions to sext instructions to avoid potential issues.
+      zextToSext(zexts);
+    }
+
     // If we found any constant offset, create new pointer calculation
     if (offset != 0) {
       llvm::IRBuilder<> builder(intrinsic);

IGC/Compiler/tests/SinkPointerConstAdd/basic.ll

@@ -21,7 +21,7 @@ GlobalScopeInitialization:
   %1 = call i64 @llvm.genx.GenISA.RuntimeValue.i64(i32 2)
   %2 = add i32 %0, 128
   %3 = zext i32 %2 to i64
-; CHECK: %2 = zext i32 %0 to i64
+; CHECK: %2 = sext i32 %0 to i64
   %4 = add i64 %1, %3
 ; CHECK-NEXT: %3 = add i64 %1, %2
 ; CHECK-NEXT: %4 = add i64 %3, 128

IGC/Compiler/tests/SinkPointerConstAdd/recursiveSub.ll

@@ -22,7 +22,7 @@ GlobalScopeInitialization:
   %2 = add i32 %0, 128
   %3 = sub i32 %2, 128
   %4 = zext i32 %3 to i64
-; CHECK: %2 = zext i32 %0 to i64
+; CHECK: %2 = sext i32 %0 to i64
   %5 = add i64 %1, %4
 ; CHECK-NEXT: %3 = add i64 %1, %2
   %ptr = inttoptr i64 %5 to i32 addrspace(1)*