[lld-macho] Don't include CommandFlags.h in CommonLinkerContext.h

[int3]

Summary

Main motivation: including llvm/CodeGen/CommandFlags.h in
CommonLinkerContext.h means that the declaration of llvm::Reloc is
visible in any file that includes CommonLinkerContext.h. Since our
cpp files have both using namespace llvm and `using namespace
lld::macho`, this results in conflicts with lld::macho::Reloc.

I suppose we could put llvm::Reloc into a nested namespace, but in general,
I think we should avoid transitively including too many header files in
a very widely used header like CommonLinkerContext.h.

RegisterCodeGenFlags' ctor initializes a bunch of function-static
structures and does nothing else, so it should be fine to "initialize"
it as a temporary stack variable rather than as a file static.

[int3]

update

[aganea]

Ideally RegisterCodeGenFlags should be a function call not a class, since it only registers static cl::opts. I think you can simply remove cgf from CommonLinkerContext.h and create a short-lived llvm::codegen::RegisterCodeGenFlags object on the stack inside the CommonLinkerContext constructor definition.

Truly, D108850 does not solve yet the multi-threading issues with cl::opts. This is something I wanted to address later (I have a few patches ready). However in the meanwhile, the objective with D108850 was also to enable -Werror=global-constructors, at least in lldCommon and lldCOFF.

[int3]

init CGF on the stack

[aganea]

LGTM, thanks!

lld/Common/CommonLinkerContext.cpp

 //===- CommonLinkerContext.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/CommonLinkerContext.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 
+#include "llvm/CodeGen/CommandFlags.h"
+
 using namespace llvm;
 using namespace lld;
 
 // Reference to the current LLD instance. This is a temporary situation, until
 // we pass this context everywhere by reference, or we make it a thread_local,
 // as in https://reviews.llvm.org/D108850?id=370678 where each thread can be
 // associated with a LLD instance. Only then will LLD be free of global
 // state.
 static CommonLinkerContext *lctx;
 
-CommonLinkerContext::CommonLinkerContext() { lctx = this; }
+CommonLinkerContext::CommonLinkerContext() {
+  lctx = this;
+  // Fire off the static initializations in CGF's constructor.
+  codegen::RegisterCodeGenFlags CGF;
+}
 
 CommonLinkerContext::~CommonLinkerContext() {
   assert(lctx);
   // Explicitly call the destructors since we created the objects with placement
   // new in SpecificAlloc::create().
   for (auto &it : instances)
     it.second->~SpecificAllocBase();
   lctx = nullptr;

lld/ELF/Writer.cpp

 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/Arrays.h"
 #include "lld/Common/CommonLinkerContext.h"
 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/Support/MD5.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/xxhash.h"
 #include <climits>
 
 #define DEBUG_TYPE "lld"

lld/MachO/ICF.cpp

 //===- ICF.cpp ------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ICF.h"
 #include "ConcatOutputSection.h"
 #include "InputSection.h"
 #include "Symbols.h"
 #include "UnwindInfoSection.h"
 
+#include "lld/Common/CommonLinkerContext.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/TimeProfiler.h"
 
 #include <atomic>
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;

lld/include/lld/Common/CommonLinkerContext.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COMMON_COMMONLINKINGCONTEXT_H
 #define LLD_COMMON_COMMONLINKINGCONTEXT_H
 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
-#include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/Support/StringSaver.h"
 
 namespace llvm {
 class raw_ostream;
 } // namespace llvm
 
 namespace lld {
 struct SpecificAllocBase;
 class CommonLinkerContext {
 public:
   CommonLinkerContext();
   virtual ~CommonLinkerContext();
 
   static void destroy();
 
   llvm::BumpPtrAllocator bAlloc;
   llvm::StringSaver saver{bAlloc};
   llvm::DenseMap<void *, SpecificAllocBase *> instances;
 
   ErrorHandler e;
-
-private:
-  llvm::codegen::RegisterCodeGenFlags cgf;
 };
 
 // Retrieve the global state. Currently only one state can exist per process,
 // but in the future we plan on supporting an arbitrary number of LLD instances
 // in a single process.
 CommonLinkerContext &commonContext();
 
 template <typename T = CommonLinkerContext> T &context() {