[NFC][HWASAN] make variables names for callback functions more consistent

[Enna1]

Summary

This patch makes the variables names for callback functions more consistent. Changes no functionality.

[Enna1]

update

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

public:
 
   void instrumentPersonalityFunctions();
 
 private:
   LLVMContext *C;
   Module &M;
   const StackSafetyGlobalInfo *SSI;
   Triple TargetTriple;
-  FunctionCallee HWAsanMemmove, HWAsanMemcpy, HWAsanMemset;
-  FunctionCallee HWAsanHandleVfork;
 
   /// This struct defines the shadow mapping using the rule:
   ///   shadow = (mem >> Scale) + Offset.
   /// If InGlobal is true, then
   ///   extern char __hwasan_shadow[];
   ///   shadow = (mem >> Scale) + &__hwasan_shadow
   /// If InTls is true, then
   ///   extern char *__hwasan_tls;
private:
   unsigned PointerTagShift;
   uint64_t TagMaskByte;
 
   Function *HwasanCtorFunction;
 
   FunctionCallee HwasanMemoryAccessCallback[2][kNumberOfAccessSizes];
   FunctionCallee HwasanMemoryAccessCallbackSized[2];
 
+  FunctionCallee HwasanMemmove, HwasanMemcpy, HwasanMemset;
+  FunctionCallee HwasanHandleVfork;
+
   FunctionCallee HwasanTagMemoryFunc;
   FunctionCallee HwasanGenerateTagFunc;
   FunctionCallee HwasanRecordFrameRecordFunc;
 
   Constant *ShadowGlobal;
 
   Value *ShadowBase = nullptr;
   Value *StackBaseTag = nullptr;
if (!TargetTriple.isAndroid()) {
     ThreadPtrGlobal = cast<GlobalVariable>(C);
   }
 }
 
 void HWAddressSanitizer::initializeCallbacks(Module &M) {
   IRBuilder<> IRB(*C);
   const std::string MatchAllStr = UseMatchAllCallback ? "_match_all" : "";
   FunctionType *HwasanMemoryAccessCallbackSizedFnTy,
-      *HwasanMemoryAccessCallbackFnTy, *HWAsanMemTransferFnTy,
-      *HWAsanMemsetFnTy;
+      *HwasanMemoryAccessCallbackFnTy, *HwasanMemTransferFnTy,
+      *HwasanMemsetFnTy;
   if (UseMatchAllCallback) {
     HwasanMemoryAccessCallbackSizedFnTy =
         FunctionType::get(VoidTy, {IntptrTy, IntptrTy, Int8Ty}, false);
     HwasanMemoryAccessCallbackFnTy =
         FunctionType::get(VoidTy, {IntptrTy, Int8Ty}, false);
-    HWAsanMemTransferFnTy = FunctionType::get(
+    HwasanMemTransferFnTy = FunctionType::get(
         Int8PtrTy, {Int8PtrTy, Int8PtrTy, IntptrTy, Int8Ty}, false);
-    HWAsanMemsetFnTy = FunctionType::get(
+    HwasanMemsetFnTy = FunctionType::get(
         Int8PtrTy, {Int8PtrTy, Int32Ty, IntptrTy, Int8Ty}, false);
   } else {
     HwasanMemoryAccessCallbackSizedFnTy =
         FunctionType::get(VoidTy, {IntptrTy, IntptrTy}, false);
     HwasanMemoryAccessCallbackFnTy =
         FunctionType::get(VoidTy, {IntptrTy}, false);
-    HWAsanMemTransferFnTy =
+    HwasanMemTransferFnTy =
         FunctionType::get(Int8PtrTy, {Int8PtrTy, Int8PtrTy, IntptrTy}, false);
-    HWAsanMemsetFnTy =
+    HwasanMemsetFnTy =
         FunctionType::get(Int8PtrTy, {Int8PtrTy, Int32Ty, IntptrTy}, false);
   }
 
   for (size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
     const std::string TypeStr = AccessIsWrite ? "store" : "load";
     const std::string EndingStr = Recover ? "_noabort" : "";
 
     HwasanMemoryAccessCallbackSized[AccessIsWrite] = M.getOrInsertFunction(
for (size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
     }
   }
 
   const std::string MemIntrinCallbackPrefix =
       (CompileKernel && !ClKasanMemIntrinCallbackPrefix)
           ? std::string("")
           : ClMemoryAccessCallbackPrefix;
 
-  HWAsanMemmove = M.getOrInsertFunction(
-      MemIntrinCallbackPrefix + "memmove" + MatchAllStr, HWAsanMemTransferFnTy);
-  HWAsanMemcpy = M.getOrInsertFunction(
-      MemIntrinCallbackPrefix + "memcpy" + MatchAllStr, HWAsanMemTransferFnTy);
-  HWAsanMemset = M.getOrInsertFunction(
-      MemIntrinCallbackPrefix + "memset" + MatchAllStr, HWAsanMemsetFnTy);
+  HwasanMemmove = M.getOrInsertFunction(
+      MemIntrinCallbackPrefix + "memmove" + MatchAllStr, HwasanMemTransferFnTy);
+  HwasanMemcpy = M.getOrInsertFunction(
+      MemIntrinCallbackPrefix + "memcpy" + MatchAllStr, HwasanMemTransferFnTy);
+  HwasanMemset = M.getOrInsertFunction(
+      MemIntrinCallbackPrefix + "memset" + MatchAllStr, HwasanMemsetFnTy);
 
   HwasanTagMemoryFunc = M.getOrInsertFunction("__hwasan_tag_memory", VoidTy,
                                               Int8PtrTy, Int8Ty, IntptrTy);
   HwasanGenerateTagFunc =
       M.getOrInsertFunction("__hwasan_generate_tag", Int8Ty);
 
   HwasanRecordFrameRecordFunc =
       M.getOrInsertFunction("__hwasan_add_frame_record", VoidTy, Int64Ty);
 
   ShadowGlobal =
       M.getOrInsertGlobal("__hwasan_shadow", ArrayType::get(Int8Ty, 0));
 
-  HWAsanHandleVfork =
+  HwasanHandleVfork =
       M.getOrInsertFunction("__hwasan_handle_vfork", VoidTy, IntptrTy);
 }
 
 Value *HWAddressSanitizer::getOpaqueNoopCast(IRBuilder<> &IRB, Value *Val) {
   // An empty inline asm with input reg == output reg.
   // An opaque no-op cast, basically.
   // This prevents code bloat as a result of rematerializing trivial definitions
   // such as constants or global addresses at every load and store.
bool HWAddressSanitizer::ignoreMemIntrinsic(MemIntrinsic *MI) {
   return false;
 }
 
 void HWAddressSanitizer::instrumentMemIntrinsic(MemIntrinsic *MI) {
   IRBuilder<> IRB(MI);
   if (isa<MemTransferInst>(MI)) {
     if (UseMatchAllCallback) {
       IRB.CreateCall(
-          isa<MemMoveInst>(MI) ? HWAsanMemmove : HWAsanMemcpy,
+          isa<MemMoveInst>(MI) ? HwasanMemmove : HwasanMemcpy,
           {IRB.CreatePointerCast(MI->getOperand(0), IRB.getInt8PtrTy()),
            IRB.CreatePointerCast(MI->getOperand(1), IRB.getInt8PtrTy()),
            IRB.CreateIntCast(MI->getOperand(2), IntptrTy, false),
            ConstantInt::get(Int8Ty, *MatchAllTag)});
     } else {
       IRB.CreateCall(
-          isa<MemMoveInst>(MI) ? HWAsanMemmove : HWAsanMemcpy,
+          isa<MemMoveInst>(MI) ? HwasanMemmove : HwasanMemcpy,
           {IRB.CreatePointerCast(MI->getOperand(0), IRB.getInt8PtrTy()),
            IRB.CreatePointerCast(MI->getOperand(1), IRB.getInt8PtrTy()),
            IRB.CreateIntCast(MI->getOperand(2), IntptrTy, false)});
     }
   } else if (isa<MemSetInst>(MI)) {
     if (UseMatchAllCallback) {
       IRB.CreateCall(
-          HWAsanMemset,
+          HwasanMemset,
           {IRB.CreatePointerCast(MI->getOperand(0), IRB.getInt8PtrTy()),
            IRB.CreateIntCast(MI->getOperand(1), IRB.getInt32Ty(), false),
            IRB.CreateIntCast(MI->getOperand(2), IntptrTy, false),
            ConstantInt::get(Int8Ty, *MatchAllTag)});
     } else {
       IRB.CreateCall(
-          HWAsanMemset,
+          HwasanMemset,
           {IRB.CreatePointerCast(MI->getOperand(0), IRB.getInt8PtrTy()),
            IRB.CreateIntCast(MI->getOperand(1), IRB.getInt32Ty(), false),
            IRB.CreateIntCast(MI->getOperand(2), IntptrTy, false)});
     }
   }
   MI->eraseFromParent();
 }
 
Value *HWAddressSanitizer::readRegister(IRBuilder<> &IRB, StringRef Name) {
   return IRB.CreateCall(ReadRegister, Args);
 }
 
 bool HWAddressSanitizer::instrumentLandingPads(
     SmallVectorImpl<Instruction *> &LandingPadVec) {
   for (auto *LP : LandingPadVec) {
     IRBuilder<> IRB(LP->getNextNode());
     IRB.CreateCall(
-        HWAsanHandleVfork,
+        HwasanHandleVfork,
         {readRegister(IRB, (TargetTriple.getArch() == Triple::x86_64) ? "rsp"
                                                                       : "sp")});
   }
   return true;
 }
 
 static bool isLifetimeIntrinsic(Value *V) {
   auto *II = dyn_cast<IntrinsicInst>(V);