AMDGPU: Don't create potentially dead rcp declarations

[arsenm]

Summary

This will introduce unused declarations if this doesn't reach any of
the paths that will really use it.

[cfang]

LGTM

[arsenm]

b87e3e2d0db8b0eb7a8f26525dad74cc7014b85f

llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

 static Value *optimizeWithRcp(Value *Num, Value *Den, bool AllowInaccurateRcp,
                               bool RcpIsAccurate, IRBuilder<> Builder,
                               Module *Mod) {
 
   if (!AllowInaccurateRcp && !RcpIsAccurate)
     return nullptr;
 
   Type *Ty = Den->getType();
-  Function *Decl = Intrinsic::getDeclaration(Mod, Intrinsic::amdgcn_rcp, Ty);
   if (const ConstantFP *CLHS = dyn_cast<ConstantFP>(Num)) {
     if (AllowInaccurateRcp || RcpIsAccurate) {
       if (CLHS->isExactlyValue(1.0)) {
+        Function *Decl = Intrinsic::getDeclaration(
+          Mod, Intrinsic::amdgcn_rcp, Ty);
+
         // v_rcp_f32 and v_rsq_f32 do not support denormals, and according to
         // the CI documentation has a worst case error of 1 ulp.
         // OpenCL requires <= 2.5 ulp for 1.0 / x, so it should always be OK to
         // use it as long as we aren't trying to use denormals.
         //
         // v_rcp_f16 and v_rsq_f16 DO support denormals.
 
         // NOTE: v_sqrt and v_rcp will be combined to v_rsq later. So we don't
         //       insert rsq intrinsic here.
 
         // 1.0 / x -> rcp(x)
         return Builder.CreateCall(Decl, { Den });
-       }
 
        // Same as for 1.0, but expand the sign out of the constant.
-       if (CLHS->isExactlyValue(-1.0)) {
+        Function *Decl = Intrinsic::getDeclaration(
+          Mod, Intrinsic::amdgcn_rcp, Ty);
+
          // -1.0 / x -> rcp (fneg x)
          Value *FNeg = Builder.CreateFNeg(Den);
          return Builder.CreateCall(Decl, { FNeg });
        }
     }
   }
 
   if (AllowInaccurateRcp) {
+    Function *Decl = Intrinsic::getDeclaration(
+      Mod, Intrinsic::amdgcn_rcp, Ty);
+
     // Turn into multiply by the reciprocal.
     // x / y -> x * (1.0 / y)
     Value *Recip = Builder.CreateCall(Decl, { Den });
     return Builder.CreateFMul(Num, Recip);
   }
   return nullptr;
 }