[mlir] UnsignedWhenEquivalent ignore dead code

[Mogball]

Summary

The pass was not checking for uninitialized states due to dead code.
This patch also makes LLVMFuncOp correctly return a null body when it is
external.

Fixes #58807

Depends on D139388

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

let extraClassDeclaration = [{
     bool isVarArg() { return getFunctionType().isVarArg(); }
 
     /// Returns the argument types of this function.
     ArrayRef<Type> getArgumentTypes() { return getFunctionType().getParams(); }
 
     /// Returns the result types of this function.
     ArrayRef<Type> getResultTypes() { return getFunctionType().getReturnTypes(); }
 
-    /// Returns the callable region, which is the function body.
-    Region *getCallableRegion() { return &getBody(); }
+    /// Returns the callable region, which is the function body. If the function
+    /// is external, returns null.
+    Region *getCallableRegion();
 
     /// Returns the callable result type, which is the function return type.
     ArrayRef<Type> getCallableResults() { return getFunctionType().getReturnTypes(); }
 
   }];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;

mlir/lib/Dialect/Arith/Transforms/UnsignedWhenEquivalent.cpp

 using namespace mlir::arith;
 using namespace mlir::dataflow;
 
 /// Succeeds when a value is statically non-negative in that it has a lower
 /// bound on its value (if it is treated as signed) and that bound is
 /// non-negative.
 static LogicalResult staticallyNonNegative(DataFlowSolver &solver, Value v) {
   auto *result = solver.lookupState<IntegerValueRangeLattice>(v);
-  if (!result)
+  if (!result || result->getValue().isUninitialized())
     return failure();
   const ConstantIntRanges &range = result->getValue().getValue();
   return success(range.smin().isNonNegative());
 }
 
 /// Succeeds if an op can be converted to its unsigned equivalent without
 /// changing its semantics. This is the case when none of its openands or
 /// results can be below 0 when analyzed from a signed perspective.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

for (unsigned i = 0; i < numArguments; ++i) {
     if (!isCompatibleType(argType))
       return emitOpError("entry block argument #")
              << i << " is not of LLVM type";
   }
 
   return success();
 }
 
+Region *LLVMFuncOp::getCallableRegion() {
+  if (isExternal())
+    return nullptr;
+  return &getBody();
+}
+
 //===----------------------------------------------------------------------===//
 // Verification for LLVM::ConstantOp.
 //===----------------------------------------------------------------------===//
 
 LogicalResult LLVM::ConstantOp::verify() {
   if (StringAttr sAttr = getValue().dyn_cast<StringAttr>()) {
     auto arrayType = getType().dyn_cast<LLVMArrayType>();
     if (!arrayType || arrayType.getNumElements() != sAttr.getValue().size() ||

mlir/test/Dialect/Arith/unsigned-when-equivalent.mlir

scf.for %arg1 = %c0 to %c8 step %c1 {
         %w = arith.addi %v, %v : index
         %test = arith.cmpi sle, %w, %c4 : index
         scf.if %test {
             memref.store %w, %arg0[%arg1] : memref<8xindex>
         }
     }
     func.return
 }
+
+func.func private @external() -> i8
+
+// CHECK-LABEL: @dead_code
+func.func @dead_code() {
+  %0 = call @external() : () -> i8
+  // CHECK: arith.floordivsi
+  %1 = arith.floordivsi %0, %0 : i8
+  return
+}

mlir/test/Dialect/LLVMIR/callgraph.mlir

 }
 
 // -----
 
 // CHECK: Testing : "Invoke call"
 module attributes {"test.name" = "Invoke call"} {
   // CHECK-LABEL: ---- CallGraph ----
   // CHECK: - Node : 'llvm.func' {{.*}} sym_name = "invokeLandingpad"
-  // CHECK-DAG: -- Call-Edge : 'llvm.func' {{.*}} sym_name = "foo"
-  // CHECK-DAG: -- Call-Edge : 'llvm.func' {{.*}} sym_name = "bar"
+  // CHECK-DAG: -- Call-Edge : <Unknown-Callee-Node>
 
   // CHECK: -- SCCs --
   llvm.mlir.global external constant @_ZTIi() : !llvm.ptr<i8>
   llvm.func @foo(%arg0: i32) -> !llvm.struct<(i32, f64, i32)>
   llvm.func @bar(!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>)
   llvm.func @__gxx_personality_v0(...) -> i32
 
   llvm.func @invokeLandingpad() -> i32 attributes { personality = @__gxx_personality_v0 } {