Rename 'module' to 'hModule' for C++20 compat (#2667)

* Rename 'module' to 'hModule' for C++20 compat
* Replace a bunch of unintended uses of new keyword 'module' with 'mod'

include/dxc/DxrFallback/DxrFallbackCompiler.h

@@ -50,7 +50,7 @@ public:
   // called by functions in shaderNames. Shader entry state IDs are still
   // returned only for those originally in shaderNames. findCalledShaders used 
   // for testing.
-  DxrFallbackCompiler(llvm::Module* module, const std::vector<std::string>& shaderNames, unsigned maxAttributeSize, unsigned stackSizeInBytes, bool findCalledShaders = false);
+  DxrFallbackCompiler(llvm::Module* mod, const std::vector<std::string>& shaderNames, unsigned maxAttributeSize, unsigned stackSizeInBytes, bool findCalledShaders = false);
 
   // 0 - no debug output
   // 1 - dump initial combined module, compiled module, and final linked module

include/dxc/Support/dxcapi.use.h

@@ -146,9 +146,9 @@ public:
   }
 
   HMODULE Detach() {
-    HMODULE module = m_dll;
+    HMODULE hModule = m_dll;
     m_dll = nullptr;
-    return module;
+    return hModule;
   }
 };
 

include/llvm/ExecutionEngine/ExecutionEngine.h

@@ -273,7 +273,7 @@ public:
   /// destructors for a particular module.
   ///
   /// \param isDtors - Run the destructors instead of constructors.
-  void runStaticConstructorsDestructors(Module &module, bool isDtors);
+  void runStaticConstructorsDestructors(Module &mod, bool isDtors);
 
 
   /// runFunctionAsMain - This is a helper function which wraps runFunction to

lib/DxilContainer/DxilContainerAssembler.cpp

@@ -483,8 +483,8 @@ private:
   }
 
 public:
-  DxilPSVWriter(const DxilModule &module, uint32_t PSVVersion = 0)
-  : m_Module(module),
+  DxilPSVWriter(const DxilModule &mod, uint32_t PSVVersion = 0)
+  : m_Module(mod),
     m_PSVInitInfo(PSVVersion)
   {
     m_Module.GetValidatorVersion(m_ValMajor, m_ValMinor);
@@ -1357,15 +1357,15 @@ private:
   SubobjectTable *m_pSubobjectTable;
 
 public:
-  DxilRDATWriter(const DxilModule &module, uint32_t InfoVersion = 0)
+  DxilRDATWriter(const DxilModule &mod, uint32_t InfoVersion = 0)
       : m_RDATBuffer(), m_Parts(), m_FuncToResNameOffset() {
     // Keep track of validator version so we can make a compatible RDAT
-    module.GetValidatorVersion(m_ValMajor, m_ValMinor);
+    mod.GetValidatorVersion(m_ValMajor, m_ValMinor);
 
     CreateParts();
-    UpdateResourceInfo(module);
-    UpdateFunctionInfo(module);
-    UpdateSubobjectInfo(module);
+    UpdateResourceInfo(mod);
+    UpdateFunctionInfo(mod);
+    UpdateSubobjectInfo(mod);
 
     // Delete any empty parts:
     std::vector<std::unique_ptr<RDATPart>>::iterator it = m_Parts.begin();

lib/DxilDia/DxilDiaSession.cpp

@@ -33,13 +33,13 @@
 
 void dxil_dia::Session::Init(
     std::shared_ptr<llvm::LLVMContext> context,
-    std::shared_ptr<llvm::Module> module,
+    std::shared_ptr<llvm::Module> mod,
     std::shared_ptr<llvm::DebugInfoFinder> finder) {
   m_pEnumTables = nullptr;
-  m_module = module;
+  m_module = mod;
   m_context = context;
   m_finder = finder;
-  m_dxilModule = llvm::make_unique<hlsl::DxilModule>(module.get());
+  m_dxilModule = llvm::make_unique<hlsl::DxilModule>(mod.get());
 
   llvm::legacy::PassManager PM;
   llvm::initializeDxilDbgValueToDbgDeclarePass(*llvm::PassRegistry::getPassRegistry());

lib/DxilDia/DxilDiaSession.h

@@ -53,7 +53,7 @@ public:
   IMalloc *GetMallocNoRef() { return m_pMalloc.p; }
 
   void Init(std::shared_ptr<llvm::LLVMContext> context,
-            std::shared_ptr<llvm::Module> module,
+            std::shared_ptr<llvm::Module> mod,
             std::shared_ptr<llvm::DebugInfoFinder> finder);
 
   llvm::NamedMDNode *Contents() { return m_contents; }

lib/DxrFallback/DxrFallbackCompiler.cpp

@@ -35,10 +35,10 @@
 using namespace hlsl;
 using namespace llvm;
 
-static std::vector<Function*> getFunctionsWithPrefix(Module* module, const std::string& prefix)
+static std::vector<Function*> getFunctionsWithPrefix(Module* mod, const std::string& prefix)
 {
   std::vector<Function*> functions;
-  for (auto F = module->begin(), E = module->end(); F != E; ++F)
+  for (auto F = mod->begin(), E = mod->end(); F != E; ++F)
   {
     StringRef name = F->getName();
     if (name.startswith(prefix))
@@ -104,9 +104,9 @@ static std::string cleanName(StringRef name)
 }
 
 
-static inline Function* getOrInsertFunction(Module* module, Function* F)
+static inline Function* getOrInsertFunction(Module* mod, Function* F)
 {
-  return dyn_cast<Function>(module->getOrInsertFunction(F->getName(), F->getFunctionType()));
+  return dyn_cast<Function>(mod->getOrInsertFunction(F->getName(), F->getFunctionType()));
 }
 
 
@@ -121,8 +121,8 @@ V get(std::map<K, V>& theMap, const K& key, V defaultVal = static_cast<V>(nullpt
 }
 
 
-DxrFallbackCompiler::DxrFallbackCompiler(llvm::Module* module, const std::vector<std::string>& shaderNames, unsigned maxAttributeSize, unsigned stackSizeInBytes, bool findCalledShaders /*= false*/)
-  : m_module(module)
+DxrFallbackCompiler::DxrFallbackCompiler(llvm::Module* mod, const std::vector<std::string>& shaderNames, unsigned maxAttributeSize, unsigned stackSizeInBytes, bool findCalledShaders /*= false*/)
+  : m_module(mod)
   , m_entryShaderNames(shaderNames)
   , m_stackSizeInBytes(stackSizeInBytes)
   , m_maxAttributeSize(maxAttributeSize)
@@ -553,24 +553,24 @@ void DxrFallbackCompiler::createStateFunctions(
 
 void DxrFallbackCompiler::createLaunchParams(Function* func)
 {
-  Module* module = func->getParent();
-  Function* rewrite_setLaunchParams = module->getFunction("rewrite_setLaunchParams");
+  Module* mod = func->getParent();
+  Function* rewrite_setLaunchParams = mod->getFunction("rewrite_setLaunchParams");
   CallInst* call = dyn_cast<CallInst>(*rewrite_setLaunchParams->user_begin());
 
-  LLVMContext& context = module->getContext();
+  LLVMContext& context = mod->getContext();
   Instruction* insertBefore = call;
 
-  Function* DTidFunc = FunctionBuilder(module, "dx.op.threadId.i32").i32().i32().i32().build();
+  Function* DTidFunc = FunctionBuilder(mod, "dx.op.threadId.i32").i32().i32().i32().build();
   Value* DTidx = CallInst::Create(DTidFunc, { makeInt32((int)hlsl::OP::OpCode::ThreadId, context), makeInt32(0, context) }, "DTidx", insertBefore);
   Value* DTidy = CallInst::Create(DTidFunc, { makeInt32((int)hlsl::OP::OpCode::ThreadId, context), makeInt32(1, context) }, "DTidy", insertBefore);
 
   Value* dimx = call->getArgOperand(1);
   Value* dimy = call->getArgOperand(2);
 
-  Function* groupIndexFunc = FunctionBuilder(module, "dx.op.flattenedThreadIdInGroup.i32").i32().i32().build();
+  Function* groupIndexFunc = FunctionBuilder(mod, "dx.op.flattenedThreadIdInGroup.i32").i32().i32().build();
   Value* groupIndex = CallInst::Create(groupIndexFunc, { makeInt32(96, context) }, "groupIndex", insertBefore);
 
-  Function* fb_setLaunchParams = module->getFunction("fb_Fallback_SetLaunchParams");
+  Function* fb_setLaunchParams = mod->getFunction("fb_Fallback_SetLaunchParams");
   Value* runtimeDataArg = call->getArgOperand(0);
   CallInst::Create(fb_setLaunchParams, { runtimeDataArg, DTidx, DTidy, dimx, dimy, groupIndex }, "", insertBefore);
 
@@ -580,9 +580,9 @@ void DxrFallbackCompiler::createLaunchParams(Function* func)
 
 void DxrFallbackCompiler::createStateDispatch(Function* func, const IntToFuncMap& stateFunctionMap, Type* runtimeDataArgTy)
 {
-  Module* module = func->getParent();
+  Module* mod = func->getParent();
   Function* dispatchFunc = createDispatchFunction(stateFunctionMap, runtimeDataArgTy);
-  Function* rewrite_dispatchFunc = module->getFunction("rewrite_dispatch");
+  Function* rewrite_dispatchFunc = mod->getFunction("rewrite_dispatch");
   rewrite_dispatchFunc->replaceAllUsesWith(dispatchFunc);
   rewrite_dispatchFunc->eraseFromParent();
 }

lib/DxrFallback/FunctionBuilder.h

@@ -16,9 +16,9 @@
 class FunctionBuilder
 {
 public:
-  FunctionBuilder(llvm::Module* module, const std::string& name)
-    : m_context(module->getContext())
-    , m_module(module)
+  FunctionBuilder(llvm::Module* mod, const std::string& name)
+    : m_context(mod->getContext())
+    , m_module(mod)
     , m_name(name)
   {}
 

lib/DxrFallback/LLVMUtils.cpp

@@ -44,31 +44,31 @@ Instruction* getInstructionAfter(Instruction* inst)
 std::unique_ptr<Module> loadModuleFromAsmFile(LLVMContext& context, const std::string& filename)
 {
   SMDiagnostic err;
-  std::unique_ptr<Module> module = parseIRFile(filename, err, context);
-  if (!module)
+  std::unique_ptr<Module> mod = parseIRFile(filename, err, context);
+  if (!mod)
   {
     err.print(filename.c_str(), errs());
     exit(1);
   }
 
-  return module;
+  return mod;
 }
 
 std::unique_ptr<Module> loadModuleFromAsmString(LLVMContext& context, const std::string& str)
 {
   SMDiagnostic  err;
   MemoryBufferRef memBuffer(str, "id");
-  std::unique_ptr<Module> module = parseIR(memBuffer, err, context);
-  return module;
+  std::unique_ptr<Module> mod = parseIR(memBuffer, err, context);
+  return mod;
 }
 
-void saveModuleToAsmFile(const llvm::Module* module, const std::string& filename)
+void saveModuleToAsmFile(const llvm::Module* mod, const std::string& filename)
 {
   std::error_code EC;
   raw_fd_ostream out(filename, EC, sys::fs::F_Text);
   if (!out.has_error())
   {
-    module->print(out, 0);
+    mod->print(out, 0);
     out.close();
   }
   if (out.has_error())
@@ -98,7 +98,7 @@ void dumpCFG(const Function* F, const std::string& suffix)
   }
 }
 
-Function* getOrCreateFunction(const std::string& name, Module* module, FunctionType* funcType, std::map<FunctionType*, Function*>& typeToFuncMap)
+Function* getOrCreateFunction(const std::string& name, Module* mod, FunctionType* funcType, std::map<FunctionType*, Function*>& typeToFuncMap)
 {
   auto it = typeToFuncMap.find(funcType);
   if (it != typeToFuncMap.end())
@@ -106,7 +106,7 @@ Function* getOrCreateFunction(const std::string& name, Module* module, FunctionT
 
   // Give name a numerical suffix to make it unique 
   std::string uniqueName = name + std::to_string(typeToFuncMap.size());
-  Function* F = dyn_cast<Function>(module->getOrInsertFunction(uniqueName, funcType));
+  Function* F = dyn_cast<Function>(mod->getOrInsertFunction(uniqueName, funcType));
   typeToFuncMap[funcType] = F;
   return F;
 }

lib/DxrFallback/StateFunctionTransform.cpp

@@ -656,9 +656,9 @@ void StateFunctionTransform::setResourceGlobals(const std::set<llvm::Value*>& re
   m_resources = &resources;
 }
 
-Function* StateFunctionTransform::createDummyRuntimeDataArgFunc(Module* module, Type* runtimeDataArgTy)
+Function* StateFunctionTransform::createDummyRuntimeDataArgFunc(Module* mod, Type* runtimeDataArgTy)
 {
-  return FunctionBuilder(module, "dummyRuntimeDataArg").type(runtimeDataArgTy).build();
+  return FunctionBuilder(mod, "dummyRuntimeDataArg").type(runtimeDataArgTy).build();
 }
 
 void StateFunctionTransform::setVerbose(bool val)
@@ -691,10 +691,10 @@ void StateFunctionTransform::run(std::vector<Function*>& stateFunctions, _Out_ u
   printFunctions(stateFunctions, "AfterLowerStackFuncs");
 }
 
-void StateFunctionTransform::finalizeStateIds(llvm::Module* module, const std::vector<int>& candidateFuncEntryStateIds)
+void StateFunctionTransform::finalizeStateIds(llvm::Module* mod, const std::vector<int>& candidateFuncEntryStateIds)
 {
-  LLVMContext& context = module->getContext();
-  Function* func = module->getFunction("dummyStateId");
+  LLVMContext& context = mod->getContext();
+  Function* func = mod->getFunction("dummyStateId");
   if (!func)
     return;
 
@@ -723,7 +723,7 @@ void StateFunctionTransform::finalizeStateIds(llvm::Module* module, const std::v
 
 void StateFunctionTransform::init()
 {
-  Module* module = m_function->getParent();
+  Module* mod = m_function->getParent();
   m_function->setName(cleanName(m_function->getName()));
 
   // Run preparatory passes
@@ -742,26 +742,26 @@ void StateFunctionTransform::init()
 
 
   // Create a bunch of functions that we are going to need
-  m_stackIntPtrFunc = FunctionBuilder(module, "stackIntPtr").i32Ptr().type(m_runtimeDataArgTy, "runtimeData").i32("baseOffset").i32("offset").build();
+  m_stackIntPtrFunc = FunctionBuilder(mod, "stackIntPtr").i32Ptr().type(m_runtimeDataArgTy, "runtimeData").i32("baseOffset").i32("offset").build();
 
   Instruction* insertBefore = afterEntryBlockAllocas(m_function);
-  Function* runtimeDataArgFunc = createDummyRuntimeDataArgFunc(module, m_runtimeDataArgTy);
+  Function* runtimeDataArgFunc = createDummyRuntimeDataArgFunc(mod, m_runtimeDataArgTy);
   m_runtimeDataArg = CallInst::Create(runtimeDataArgFunc, "runtimeData", insertBefore);
 
-  Function* stackFrameSizeFunc = FunctionBuilder(module, "dummyStackFrameSize").i32().build();
+  Function* stackFrameSizeFunc = FunctionBuilder(mod, "dummyStackFrameSize").i32().build();
   m_stackFrameSizeVal = CallInst::Create(stackFrameSizeFunc, "stackFrame.size", insertBefore);
 
   // TODO only create the values that are actually needed
-  Function* payloadOffsetFunc = FunctionBuilder(module, "payloadOffset").i32().type(m_runtimeDataArgTy, "runtimeData").build();
+  Function* payloadOffsetFunc = FunctionBuilder(mod, "payloadOffset").i32().type(m_runtimeDataArgTy, "runtimeData").build();
   m_payloadOffset = CallInst::Create(payloadOffsetFunc, { m_runtimeDataArg }, "payload.offset", insertBefore);
 
-  Function* committedAttrOffsetFunc = FunctionBuilder(module, "committedAttrOffset").i32().type(m_runtimeDataArgTy, "runtimeData").build();
+  Function* committedAttrOffsetFunc = FunctionBuilder(mod, "committedAttrOffset").i32().type(m_runtimeDataArgTy, "runtimeData").build();
   m_committedAttrOffset = CallInst::Create(committedAttrOffsetFunc, { m_runtimeDataArg }, "committedAttr.offset", insertBefore);
 
-  Function* pendingAttrOffsetFunc = FunctionBuilder(module, "pendingAttrOffset").i32().type(m_runtimeDataArgTy, "runtimeData").build();
+  Function* pendingAttrOffsetFunc = FunctionBuilder(mod, "pendingAttrOffset").i32().type(m_runtimeDataArgTy, "runtimeData").build();
   m_pendingAttrOffset = CallInst::Create(pendingAttrOffsetFunc, { m_runtimeDataArg }, "pendingAttr.offset", insertBefore);
 
-  Function* stackFrameOffsetFunc = FunctionBuilder(module, "stackFrameOffset").i32().type(m_runtimeDataArgTy, "runtimeData").build();
+  Function* stackFrameOffsetFunc = FunctionBuilder(mod, "stackFrameOffset").i32().type(m_runtimeDataArgTy, "runtimeData").build();
   m_stackFrameOffset = CallInst::Create(stackFrameOffsetFunc, { m_runtimeDataArg }, "stackFrame.offset", insertBefore);
 
 
@@ -913,8 +913,8 @@ void StateFunctionTransform::preserveLiveValuesAcrossCallsites(_Out_ unsigned in
 
 
   // ... live allocas. 
-  Module* module = m_function->getParent();
-  DataLayout DL(module);
+  Module* mod = m_function->getParent();
+  DataLayout DL(mod);
   DenseMap<Instruction*, Instruction*> allocaToStack;
   Instruction* insertBefore = getInstructionAfter(m_stackFrameOffset);
   for (Instruction* inst : lv.getAllLiveValues())
@@ -1062,15 +1062,15 @@ void StateFunctionTransform::createSubstateFunctions(std::vector<Function*>& sta
 
 void StateFunctionTransform::allocateStackFrame()
 {
-  Module* module = m_function->getParent();
+  Module* mod = m_function->getParent();
 
   // Push stack frame in entry block. 
   Instruction* insertBefore = m_stackFrameOffset;
-  Function* stackFramePushFunc = FunctionBuilder(module, "stackFramePush").voidTy().type(m_runtimeDataArgTy, "runtimeData").i32("size").build();
+  Function* stackFramePushFunc = FunctionBuilder(mod, "stackFramePush").voidTy().type(m_runtimeDataArgTy, "runtimeData").i32("size").build();
   m_stackFramePush = CallInst::Create(stackFramePushFunc, { m_runtimeDataArg, m_stackFrameSizeVal }, "", insertBefore);
 
   // Pop the stack frame just before returns.
-  Function* stackFramePop = FunctionBuilder(module, "stackFramePop").voidTy().type(m_runtimeDataArgTy, "runtimeData").i32("size").build();
+  Function* stackFramePop = FunctionBuilder(mod, "stackFramePop").voidTy().type(m_runtimeDataArgTy, "runtimeData").i32("size").build();
   for (Instruction* insertBefore : m_returns)
     CallInst::Create(stackFramePop, { m_runtimeDataArg, m_stackFrameSizeVal }, "", insertBefore);
 }
@@ -1086,14 +1086,14 @@ void StateFunctionTransform::allocateTraceFrame()
 
   // Push the trace frame first thing so that the runtime 
   // can do setup relative to the entry stack offset.
-  Module* module = m_function->getParent();
+  Module* mod = m_function->getParent();
   Instruction* insertBefore = afterEntryBlockAllocas(m_function);
-  Value* attrSize = makeInt32(attrSizeInInts, module->getContext());
-  Function* traceFramePushFunc = FunctionBuilder(module, "traceFramePush").voidTy().type(m_runtimeDataArgTy, "runtimeData").i32("attrSize").build();
+  Value* attrSize = makeInt32(attrSizeInInts, mod->getContext());
+  Function* traceFramePushFunc = FunctionBuilder(mod, "traceFramePush").voidTy().type(m_runtimeDataArgTy, "runtimeData").i32("attrSize").build();
   CallInst::Create(traceFramePushFunc, { m_runtimeDataArg, attrSize }, "", insertBefore);
 
   // Pop the trace frame just before returns.
-  Function* traceFramePopFunc = FunctionBuilder(module, "traceFramePop").voidTy().type(m_runtimeDataArgTy, "runtimeData").build();
+  Function* traceFramePopFunc = FunctionBuilder(mod, "traceFramePop").voidTy().type(m_runtimeDataArgTy, "runtimeData").build();
   for (Instruction* insertBefore : m_returns)
     CallInst::Create(traceFramePopFunc, { m_runtimeDataArg }, "", insertBefore);
 }
@@ -1109,8 +1109,8 @@ bool isTemporaryAlloca(Value* op)
 
 void StateFunctionTransform::createArgFrames()
 {
-  Module* module = m_function->getParent();
-  DataLayout DL(module);
+  Module* mod = m_function->getParent();
+  DataLayout DL(mod);
   Instruction* stackAllocaInsertBefore = getInstructionAfter(m_stackFrameOffset);
 
   // Retrieve this function's arguments from the stack
@@ -1591,8 +1591,8 @@ Function* StateFunctionTransform::split(Function* baseFunc, BasicBlock* substate
 {
   ValueToValueMapTy VMap;
   Function*         substateFunc = cloneBlocksReachableFrom(substateEntryBlock, VMap);
-  Module*           module = baseFunc->getParent();
-  module->getFunctionList().push_back(substateFunc);
+  Module*           mod = baseFunc->getParent();
+  mod->getFunctionList().push_back(substateFunc);
   substateFunc->setName(m_functionName + ".ss_" + std::to_string(substateIndex));
 
   if (substateIndex != 0)
@@ -1742,14 +1742,14 @@ void StateFunctionTransform::printFunctions(const std::vector<Function*>& funcs,
     delete &out;
 }
 
-void StateFunctionTransform::printModule(const Module* module, const std::string& suffix)
+void StateFunctionTransform::printModule(const Module* mod, const std::string& suffix)
 {
   if (!m_verbose)
     return;
 
   raw_ostream& out = getOutputStream("module", suffix, m_dumpId++);
   out << "; ########################### " << suffix << "\n";
-  out << *module << "\n";
+  out << *mod << "\n";
 }
 
 void StateFunctionTransform::printSet(const InstructionSetVector& vals, const char* msg)
@@ -1764,8 +1764,8 @@ void StateFunctionTransform::printSet(const InstructionSetVector& vals, const ch
   uint64_t totalBytes = 0;
   if (vals.size() > 0)
   {
-    Module*    module = m_function->getParent();
-    DataLayout DL(module);
+    Module*    mod = m_function->getParent();
+    DataLayout DL(mod);
     for (InstructionSetVector::const_iterator I = vals.begin(), IE = vals.end(); I != IE; ++I)
     {
       const Instruction* inst = *I;

lib/ExecutionEngine/ExecutionEngine.cpp

@@ -360,10 +360,10 @@ void *ArgvArray::reset(LLVMContext &C, ExecutionEngine *EE,
   return Array.get();
 }
 
-void ExecutionEngine::runStaticConstructorsDestructors(Module &module,
+void ExecutionEngine::runStaticConstructorsDestructors(Module &mod,
                                                        bool isDtors) {
   const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors";
-  GlobalVariable *GV = module.getNamedGlobal(Name);
+  GlobalVariable *GV = mod.getNamedGlobal(Name);
 
   // If this global has internal linkage, or if it has a use, then it must be
   // an old-style (llvmgcc3) static ctor with __main linked in and in use.  If

lib/HLSL/DxilContainerReflection.cpp

@@ -1944,16 +1944,16 @@ HRESULT DxilModuleReflection::LoadModule(const DxilPartHeader *pShaderPart) {
         bBitcodeLoadError |= diagInfo.getSeverity() == DS_Error;
       };
 #if 0 // We materialize eagerly, because we'll need to walk instructions to look for usage information.
-    ErrorOr<std::unique_ptr<Module>> module =
+    ErrorOr<std::unique_ptr<Module>> mod =
         getLazyBitcodeModule(std::move(pMemBuffer), Context, errorHandler);
 #else
-    ErrorOr<std::unique_ptr<Module>> module =
+    ErrorOr<std::unique_ptr<Module>> mod =
       parseBitcodeFile(pMemBuffer->getMemBufferRef(), Context, errorHandler);
 #endif
-    if (!module || bBitcodeLoadError) {
+    if (!mod || bBitcodeLoadError) {
       return E_INVALIDARG;
     }
-    std::swap(m_pModule, module.get());
+    std::swap(m_pModule, mod.get());
     m_pDxilModule = &m_pModule->GetOrCreateDxilModule();
 
     unsigned ValMajor, ValMinor;

tools/clang/include/clang-c/Index.h

@@ -5237,7 +5237,7 @@ typedef struct {
   /**
    * \brief The imported module or NULL if the AST file is a PCH.
    */
-  CXModule module;
+  CXModule mod;
   /**
    * \brief Location where the file is imported. Applicable only for modules.
    */

tools/clang/include/clang/Lex/ModuleLoader.h

@@ -36,8 +36,8 @@ class ModuleLoadResult {
 public:
   ModuleLoadResult() : Storage() { }
 
-  ModuleLoadResult(Module *module, bool missingExpected)
-    : Storage(module, missingExpected) { }
+  ModuleLoadResult(Module *mod, bool missingExpected)
+    : Storage(mod, missingExpected) { }
 
   operator Module *() const { return Storage.getPointer(); }
 

tools/clang/include/clang/Lex/PreprocessorOptions.h

@@ -129,12 +129,12 @@ public:
     llvm::StringSet<> Failed;
 
   public:
-    bool hasAlreadyFailed(StringRef module) {
-      return Failed.count(module) > 0;
+    bool hasAlreadyFailed(StringRef mod) {
+      return Failed.count(mod) > 0;
     }
 
-    void addFailed(StringRef module) {
-      Failed.insert(module);
+    void addFailed(StringRef mod) {
+      Failed.insert(mod);
     }
   };
   

tools/clang/include/clang/SPIRV/SpirvBuilder.h

@@ -45,7 +45,7 @@ public:
   SpirvBuilder &operator=(SpirvBuilder &&) = delete;
 
   /// Returns the SPIR-V module being built.
-  SpirvModule *getModule() { return module; }
+  SpirvModule *getModule() { return mod; }
 
   // === Function and Basic Block ===
 
@@ -569,7 +569,7 @@ private:
   ASTContext &astContext;
   SpirvContext &context; ///< From which we allocate various SPIR-V object
 
-  SpirvModule *module;          ///< The current module being built
+  SpirvModule *mod;             ///< The current module being built
   SpirvFunction *function;      ///< The current function being built
   SpirvBasicBlock *insertPoint; ///< The current basic block being built
 
@@ -595,22 +595,22 @@ private:
 };
 
 void SpirvBuilder::requireCapability(spv::Capability cap, SourceLocation loc) {
-  module->addCapability(new (context) SpirvCapability(loc, cap));
+  mod->addCapability(new (context) SpirvCapability(loc, cap));
 }
 
 void SpirvBuilder::requireExtension(llvm::StringRef ext, SourceLocation loc) {
-  module->addExtension(new (context) SpirvExtension(loc, ext));
+  mod->addExtension(new (context) SpirvExtension(loc, ext));
 }
 
 void SpirvBuilder::setMemoryModel(spv::AddressingModel addrModel,
                                   spv::MemoryModel memModel) {
-  module->setMemoryModel(new (context) SpirvMemoryModel(addrModel, memModel));
+  mod->setMemoryModel(new (context) SpirvMemoryModel(addrModel, memModel));
 }
 
 void SpirvBuilder::addEntryPoint(spv::ExecutionModel em, SpirvFunction *target,
                                  std::string targetName,
                                  llvm::ArrayRef<SpirvVariable *> interfaces) {
-  module->addEntryPoint(new (context) SpirvEntryPoint(
+  mod->addEntryPoint(new (context) SpirvEntryPoint(
       target->getSourceLocation(), em, target, targetName, interfaces));
 }
 
@@ -627,7 +627,7 @@ SpirvBuilder::setDebugSource(uint32_t major, uint32_t minor,
     SpirvSource *debugSource = new (context)
         SpirvSource(/*SourceLocation*/ {}, spv::SourceLanguage::HLSL, version,
                     fileString, content);
-    module->addDebugSource(debugSource);
+    mod->addDebugSource(debugSource);
     if (!mainSource)
       mainSource = debugSource;
   }
@@ -638,7 +638,7 @@ SpirvBuilder::setDebugSource(uint32_t major, uint32_t minor,
     mainSource = new (context)
         SpirvSource(/*SourceLocation*/ {}, spv::SourceLanguage::HLSL, version,
                     nullptr, content);
-    module->addDebugSource(mainSource);
+    mod->addDebugSource(mainSource);
   }
   return mainSource->getFile();
 }
@@ -647,7 +647,7 @@ void SpirvBuilder::addExecutionMode(SpirvFunction *entryPoint,
                                     spv::ExecutionMode em,
                                     llvm::ArrayRef<uint32_t> params,
                                     SourceLocation loc) {
-  module->addExecutionMode(
+  mod->addExecutionMode(
       new (context) SpirvExecutionMode(loc, entryPoint, em, params, false));
 }
 

tools/clang/lib/SPIRV/SpirvBuilder.cpp

@@ -21,9 +21,9 @@ namespace spirv {
 
 SpirvBuilder::SpirvBuilder(ASTContext &ac, SpirvContext &ctx,
                            const SpirvCodeGenOptions &opt)
-    : astContext(ac), context(ctx), module(nullptr), function(nullptr),
+    : astContext(ac), context(ctx), mod(nullptr), function(nullptr),
       spirvOptions(opt) {
-  module = new (context) SpirvModule;
+  mod = new (context) SpirvModule;
 }
 
 SpirvFunction *SpirvBuilder::beginFunction(QualType returnType,
@@ -82,7 +82,7 @@ void SpirvBuilder::endFunction() {
   }
   basicBlocks.clear();
 
-  module->addFunction(function);
+  mod->addFunction(function);
   function = nullptr;
   insertPoint = nullptr;
 }
@@ -769,17 +769,17 @@ SpirvBuilder::createRayTracingOpsNV(spv::Op opcode, QualType resultType,
 }
 
 void SpirvBuilder::addModuleProcessed(llvm::StringRef process) {
-  module->addModuleProcessed(new (context) SpirvModuleProcessed({}, process));
+  mod->addModuleProcessed(new (context) SpirvModuleProcessed({}, process));
 }
 
 SpirvExtInstImport *SpirvBuilder::getGLSLExtInstSet() {
-  SpirvExtInstImport *glslSet = module->getGLSLExtInstSet();
+  SpirvExtInstImport *glslSet = mod->getGLSLExtInstSet();
   if (!glslSet) {
     // The extended instruction set is likely required for several different
     // reasons. We can't pinpoint the source location for one specific function.
     glslSet =
         new (context) SpirvExtInstImport(/*SourceLocation*/ {}, "GLSL.std.450");
-    module->addExtInstSet(glslSet);
+    mod->addExtInstSet(glslSet);
   }
   return glslSet;
 }
@@ -791,7 +791,7 @@ SpirvVariable *SpirvBuilder::addStageIOVar(QualType type,
   // Note: We store the underlying type in the variable, *not* the pointer type.
   auto *var = new (context) SpirvVariable(type, loc, storageClass, isPrecise);
   var->setDebugName(name);
-  module->addVariable(var);
+  mod->addVariable(var);
   return var;
 }
 
@@ -813,12 +813,12 @@ SpirvVariable *SpirvBuilder::addStageBuiltinVar(QualType type,
 
   // Note: We store the underlying type in the variable, *not* the pointer type.
   auto *var = new (context) SpirvVariable(type, loc, storageClass, isPrecise);
-  module->addVariable(var);
+  mod->addVariable(var);
 
   // Decorate with the specified Builtin
   auto *decor = new (context) SpirvDecoration(
       loc, var, spv::Decoration::BuiltIn, {static_cast<uint32_t>(builtin)});
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 
   // Add variable to cache.
   builtinVars.emplace_back(storageClass, builtin, var);
@@ -837,7 +837,7 @@ SpirvBuilder::addModuleVar(QualType type, spv::StorageClass storageClass,
       new (context) SpirvVariable(type, loc, storageClass, isPrecise,
                                   init.hasValue() ? init.getValue() : nullptr);
   var->setDebugName(name);
-  module->addVariable(var);
+  mod->addVariable(var);
   return var;
 }
 
@@ -852,7 +852,7 @@ SpirvVariable *SpirvBuilder::addModuleVar(
                                   init.hasValue() ? init.getValue() : nullptr);
   var->setResultType(type);
   var->setDebugName(name);
-  module->addVariable(var);
+  mod->addVariable(var);
   return var;
 }
 
@@ -861,14 +861,14 @@ void SpirvBuilder::decorateLocation(SpirvInstruction *target,
   auto *decor =
       new (context) SpirvDecoration(target->getSourceLocation(), target,
                                     spv::Decoration::Location, {location});
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decorateIndex(SpirvInstruction *target, uint32_t index,
                                  SourceLocation srcLoc) {
   auto *decor = new (context)
       SpirvDecoration(srcLoc, target, spv::Decoration::Index, {index});
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decorateDSetBinding(SpirvVariable *target,
@@ -877,7 +877,7 @@ void SpirvBuilder::decorateDSetBinding(SpirvVariable *target,
   const SourceLocation srcLoc = target->getSourceLocation();
   auto *dset = new (context) SpirvDecoration(
       srcLoc, target, spv::Decoration::DescriptorSet, {setNumber});
-  module->addDecoration(dset);
+  mod->addDecoration(dset);
 
   auto *binding = new (context) SpirvDecoration(
       srcLoc, target, spv::Decoration::Binding, {bindingNumber});
@@ -885,14 +885,14 @@ void SpirvBuilder::decorateDSetBinding(SpirvVariable *target,
   target->setDescriptorSetNo(setNumber);
   target->setBindingNo(bindingNumber);
 
-  module->addDecoration(binding);
+  mod->addDecoration(binding);
 }
 
 void SpirvBuilder::decorateSpecId(SpirvInstruction *target, uint32_t specId,
                                   SourceLocation srcLoc) {
   auto *decor = new (context)
       SpirvDecoration(srcLoc, target, spv::Decoration::SpecId, {specId});
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decorateInputAttachmentIndex(SpirvInstruction *target,
@@ -900,7 +900,7 @@ void SpirvBuilder::decorateInputAttachmentIndex(SpirvInstruction *target,
                                                 SourceLocation srcLoc) {
   auto *decor = new (context) SpirvDecoration(
       srcLoc, target, spv::Decoration::InputAttachmentIndex, {indexNumber});
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decorateCounterBuffer(SpirvInstruction *mainBuffer,
@@ -910,7 +910,7 @@ void SpirvBuilder::decorateCounterBuffer(SpirvInstruction *mainBuffer,
     auto *decor = new (context) SpirvDecoration(
         srcLoc, mainBuffer, spv::Decoration::HlslCounterBufferGOOGLE,
         {counterBuffer});
-    module->addDecoration(decor);
+    mod->addDecoration(decor);
   }
 }
 
@@ -921,7 +921,7 @@ void SpirvBuilder::decorateHlslSemantic(SpirvInstruction *target,
     auto *decor = new (context) SpirvDecoration(
         target->getSourceLocation(), target,
         spv::Decoration::HlslSemanticGOOGLE, semantic, memberIdx);
-    module->addDecoration(decor);
+    mod->addDecoration(decor);
   }
 }
 
@@ -929,66 +929,66 @@ void SpirvBuilder::decorateCentroid(SpirvInstruction *target,
                                     SourceLocation srcLoc) {
   auto *decor =
       new (context) SpirvDecoration(srcLoc, target, spv::Decoration::Centroid);
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decorateFlat(SpirvInstruction *target,
                                 SourceLocation srcLoc) {
   auto *decor =
       new (context) SpirvDecoration(srcLoc, target, spv::Decoration::Flat);
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decorateNoPerspective(SpirvInstruction *target,
                                          SourceLocation srcLoc) {
   auto *decor = new (context)
       SpirvDecoration(srcLoc, target, spv::Decoration::NoPerspective);
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decorateSample(SpirvInstruction *target,
                                   SourceLocation srcLoc) {
   auto *decor =
       new (context) SpirvDecoration(srcLoc, target, spv::Decoration::Sample);
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decoratePatch(SpirvInstruction *target,
                                  SourceLocation srcLoc) {
   auto *decor =
       new (context) SpirvDecoration(srcLoc, target, spv::Decoration::Patch);
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decorateNoContraction(SpirvInstruction *target,
                                          SourceLocation srcLoc) {
   auto *decor = new (context)
       SpirvDecoration(srcLoc, target, spv::Decoration::NoContraction);
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decoratePerPrimitiveNV(SpirvInstruction *target,
                                           SourceLocation srcLoc) {
   auto *decor = new (context)
       SpirvDecoration(srcLoc, target, spv::Decoration::PerPrimitiveNV);
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 void SpirvBuilder::decoratePerTaskNV(SpirvInstruction *target, uint32_t offset,
                                      SourceLocation srcLoc) {
   auto *decor =
       new (context) SpirvDecoration(srcLoc, target, spv::Decoration::PerTaskNV);
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
   decor = new (context)
       SpirvDecoration(srcLoc, target, spv::Decoration::Offset, {offset});
-  module->addDecoration(decor);
+  mod->addDecoration(decor);
 }
 
 SpirvConstant *SpirvBuilder::getConstantInt(QualType type, llvm::APInt value,
                                             bool specConst) {
   // We do not reuse existing constant integers. Just create a new one.
   auto *intConst = new (context) SpirvConstantInteger(type, value, specConst);
-  module->addConstant(intConst);
+  mod->addConstant(intConst);
   return intConst;
 }
 
@@ -997,7 +997,7 @@ SpirvConstant *SpirvBuilder::getConstantFloat(QualType type,
                                               bool specConst) {
   // We do not reuse existing constant floats. Just create a new one.
   auto *floatConst = new (context) SpirvConstantFloat(type, value, specConst);
-  module->addConstant(floatConst);
+  mod->addConstant(floatConst);
   return floatConst;
 }
 
@@ -1005,7 +1005,7 @@ SpirvConstant *SpirvBuilder::getConstantBool(bool value, bool specConst) {
   // We do not care about making unique constants at this point.
   auto *boolConst =
       new (context) SpirvConstantBoolean(astContext.BoolTy, value, specConst);
-  module->addConstant(boolConst);
+  mod->addConstant(boolConst);
   return boolConst;
 }
 
@@ -1016,14 +1016,14 @@ SpirvBuilder::getConstantComposite(QualType compositeType,
   // We do not care about making unique constants at this point.
   auto *compositeConst = new (context)
       SpirvConstantComposite(compositeType, constituents, specConst);
-  module->addConstant(compositeConst);
+  mod->addConstant(compositeConst);
   return compositeConst;
 }
 
 SpirvConstant *SpirvBuilder::getConstantNull(QualType type) {
   // We do not care about making unique constants at this point.
   auto *nullConst = new (context) SpirvConstantNull(type);
-  module->addConstant(nullConst);
+  mod->addConstant(nullConst);
   return nullConst;
 }
 
@@ -1036,22 +1036,22 @@ std::vector<uint32_t> SpirvBuilder::takeModule() {
   PreciseVisitor preciseVisitor(context, spirvOptions);
   EmitVisitor emitVisitor(astContext, context, spirvOptions);
 
-  module->invokeVisitor(&literalTypeVisitor, true);
+  mod->invokeVisitor(&literalTypeVisitor, true);
 
   // Lower types
-  module->invokeVisitor(&lowerTypeVisitor);
+  mod->invokeVisitor(&lowerTypeVisitor);
 
   // Add necessary capabilities and extensions
-  module->invokeVisitor(&capabilityVisitor);
+  mod->invokeVisitor(&capabilityVisitor);
 
   // Propagate RelaxedPrecision decorations
-  module->invokeVisitor(&relaxedPrecisionVisitor);
+  mod->invokeVisitor(&relaxedPrecisionVisitor);
 
   // Propagate NoContraction decorations
-  module->invokeVisitor(&preciseVisitor, true);
+  mod->invokeVisitor(&preciseVisitor, true);
 
   // Emit SPIR-V
-  module->invokeVisitor(&emitVisitor);
+  mod->invokeVisitor(&emitVisitor);
 
   return emitVisitor.takeBinary();
 }

tools/clang/lib/SPIRV/SpirvEmitter.cpp

@@ -142,7 +142,7 @@ bool isReferencingNonAliasStructuredOrByteBuffer(const Expr *expr) {
   return false;
 }
 
-bool spirvToolsLegalize(spv_target_env env, std::vector<uint32_t> *module,
+bool spirvToolsLegalize(spv_target_env env, std::vector<uint32_t> *mod,
                         std::string *messages) {
   spvtools::Optimizer optimizer(env);
 
@@ -160,10 +160,10 @@ bool spirvToolsLegalize(spv_target_env env, std::vector<uint32_t> *module,
 
   optimizer.RegisterPass(spvtools::CreateCompactIdsPass());
 
-  return optimizer.Run(module->data(), module->size(), module, options);
+  return optimizer.Run(mod->data(), mod->size(), mod, options);
 }
 
-bool spirvToolsOptimize(spv_target_env env, std::vector<uint32_t> *module,
+bool spirvToolsOptimize(spv_target_env env, std::vector<uint32_t> *mod,
                         clang::spirv::SpirvCodeGenOptions &spirvOptions,
                         std::string *messages) {
   spvtools::Optimizer optimizer(env);
@@ -191,12 +191,12 @@ bool spirvToolsOptimize(spv_target_env env, std::vector<uint32_t> *module,
       return false;
   }
 
-  return optimizer.Run(module->data(), module->size(), module, options);
+  return optimizer.Run(mod->data(), mod->size(), mod, options);
 }
 
 bool spirvToolsValidate(spv_target_env env, const SpirvCodeGenOptions &opts,
                         bool beforeHlslLegalization,
-                        std::vector<uint32_t> *module, std::string *messages) {
+                        std::vector<uint32_t> *mod, std::string *messages) {
   spvtools::SpirvTools tools(env);
 
   tools.SetMessageConsumer(
@@ -217,7 +217,7 @@ bool spirvToolsValidate(spv_target_env env, const SpirvCodeGenOptions &opts,
     options.SetRelaxBlockLayout(true);
   }
 
-  return tools.Validate(module->data(), module->size(), options);
+  return tools.Validate(mod->data(), mod->size(), options);
 }
 
 /// Translates atomic HLSL opcodes into the equivalent SPIR-V opcode.

tools/clang/tools/c-index-test/c-index-test.c

@@ -2929,8 +2929,8 @@ static CXIdxClientFile index_importedASTFile(CXClientData client_data,
   
   printf("[importedASTFile]: ");
   printCXIndexFile((CXIdxClientFile)info->file);
-  if (info->module) {
-    CXString name = clang_Module_getFullName(info->module);
+  if (info->mod) {
+    CXString name = clang_Module_getFullName(info->mod);
     printf(" | loc: ");
     printCXIndexLoc(info->loc, client_data);
     printf(" | name: \"%s\"", clang_getCString(name));

tools/clang/tools/dxrfallbackcompiler/dxcdxrfallbackcompiler.cpp

@@ -110,13 +110,13 @@ static DxilModule* ExtractDxil(LLVMContext& context, IDxcBlob* pContainer)
 }
 
 
-static void saveModuleToAsmFile(const llvm::Module* module, const std::string& filename)
+static void saveModuleToAsmFile(const llvm::Module* mod, const std::string& filename)
 {
   std::error_code EC;
   raw_fd_ostream out(filename, EC, sys::fs::F_Text);
   if (!out.has_error())
   {
-    module->print(out, nullptr);
+    mod->print(out, nullptr);
     out.close();
   }
   if (out.has_error())

tools/llvm-objdump/MachODump.cpp

@@ -2974,11 +2974,11 @@ inline void swapStruct(struct message_ref32 &mr) {
   sys::swapByteOrder(mr.sel);
 }
 
-inline void swapStruct(struct objc_module_t &module) {
-  sys::swapByteOrder(module.version);
-  sys::swapByteOrder(module.size);
-  sys::swapByteOrder(module.name);
-  sys::swapByteOrder(module.symtab);
+inline void swapStruct(struct objc_module_t &mod) {
+  sys::swapByteOrder(mod.version);
+  sys::swapByteOrder(mod.size);
+  sys::swapByteOrder(mod.name);
+  sys::swapByteOrder(mod.symtab);
 }
 
 inline void swapStruct(struct objc_symtab_t &symtab) {
@@ -5316,7 +5316,7 @@ static void printObjc2_32bit_MetaData(MachOObjectFile *O, bool verbose) {
 static bool printObjc1_32bit_MetaData(MachOObjectFile *O, bool verbose) {
   uint32_t i, j, p, offset, xoffset, left, defs_left, def;
   const char *r, *name, *defs;
-  struct objc_module_t module;
+  struct objc_module_t mod;
   SectionRef S, xS;
   struct objc_symtab_t symtab;
   struct objc_class_t objc_class;
@@ -5357,34 +5357,34 @@ static bool printObjc1_32bit_MetaData(MachOObjectFile *O, bool verbose) {
     r = get_pointer_32(p, offset, left, S, &info, true);
     if (r == nullptr)
       return true;
-    memset(&module, '\0', sizeof(struct objc_module_t));
+    memset(&mod, '\0', sizeof(struct objc_module_t));
     if (left < sizeof(struct objc_module_t)) {
-      memcpy(&module, r, left);
+      memcpy(&mod, r, left);
       outs() << "   (module extends past end of __module_info section)\n";
     } else
-      memcpy(&module, r, sizeof(struct objc_module_t));
+      memcpy(&mod, r, sizeof(struct objc_module_t));
     if (O->isLittleEndian() != sys::IsLittleEndianHost)
-      swapStruct(module);
+      swapStruct(mod);
 
     outs() << "Module " << format("0x%" PRIx32, p) << "\n";
-    outs() << "    version " << module.version << "\n";
-    outs() << "       size " << module.size << "\n";
+    outs() << "    version " << mod.version << "\n";
+    outs() << "       size " << mod.size << "\n";
     outs() << "       name ";
-    name = get_pointer_32(module.name, xoffset, left, xS, &info, true);
+    name = get_pointer_32(mod.name, xoffset, left, xS, &info, true);
     if (name != nullptr)
       outs() << format("%.*s", left, name);
     else
-      outs() << format("0x%08" PRIx32, module.name)
+      outs() << format("0x%08" PRIx32, mod.name)
              << "(not in an __OBJC section)";
     outs() << "\n";
 
-    r = get_pointer_32(module.symtab, xoffset, left, xS, &info, true);
-    if (module.symtab == 0 || r == nullptr) {
-      outs() << "     symtab " << format("0x%08" PRIx32, module.symtab)
+    r = get_pointer_32(mod.symtab, xoffset, left, xS, &info, true);
+    if (mod.symtab == 0 || r == nullptr) {
+      outs() << "     symtab " << format("0x%08" PRIx32, mod.symtab)
              << " (not in an __OBJC section)\n";
       continue;
     }
-    outs() << "     symtab " << format("0x%08" PRIx32, module.symtab) << "\n";
+    outs() << "     symtab " << format("0x%08" PRIx32, mod.symtab) << "\n";
     memset(&symtab, '\0', sizeof(struct objc_symtab_t));
     defs_left = 0;
     defs = nullptr;