[OpaquePtrs][Clang] Add -normalize-opaque-pointers cc1 option

[nikic]

Summary

This is a reboot of D117778 on the clang side. This option will generate IR using typed pointers and then convert it to opaque pointers at the end for printing purposes only. This allows making the test output compatible with opaque pointers, while continuing to test typed pointers.

The migration plan here would be:

1. Gradually convert ~2.5k affected clang tests to -normalize-opaque-pointers (without losing typed pointer coverage).
2. Flip the default to enable opaque pointers in clang.
3. Gradually convert tests to use opaque pointers in llvm/, while losing typed pointer coverage.
4. Flip the default to enable opaque pointers in LLVM.

Alternatively we can directly migrate clang tests to use opaque pointers before the default switch. This would carry a higher risk of breaking typed pointer support while it is still the default.

This patch just migrates a single test, but I have some half-finished automation for helping with mass migration.

[nikic]

As indicated in https://discourse.llvm.org/t/enabling-opaque-pointers-by-default/61322/9?u=nikic, I no longer think that this approach makes sense.

clang/include/clang/Basic/CodeGenOptions.def

 
 /// Whether to skip RAX setup when passing variable arguments (x86 only).
 CODEGENOPT(SkipRaxSetup, 1, 0)
 
 /// Whether to zero out caller-used registers before returning.
 ENUM_CODEGENOPT(ZeroCallUsedRegs, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind,
                 5, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Skip)
 
+/// Whether to normalize result to opaque pointers.
+CODEGENOPT(NormalizeOpaquePointers, 1, 0)
+
 #undef CODEGENOPT
 #undef ENUM_CODEGENOPT
 #undef VALUE_CODEGENOPT

clang/include/clang/Driver/Options.td

defm enable_noundef_analysis : BoolOption<"",
   CodeGenOpts<"EnableNoundefAttrs">,
   DefaultTrue,
   PosFlag<SetTrue, [], "Enable">,
   NegFlag<SetFalse, [], "Disable">,
   BothFlags<[], " analyzing function argument and return types for mandatory definedness">>;
 def discard_value_names : Flag<["-"], "discard-value-names">,
   HelpText<"Discard value names in LLVM IR">,
   MarshallingInfoFlag<CodeGenOpts<"DiscardValueNames">>;
+def normalize_opaque_pointers : Flag<["-"], "normalize-opaque-pointers">,
+  HelpText<"Normalize final output to opaque pointers">,
+  MarshallingInfoFlag<CodeGenOpts<"NormalizeOpaquePointers">>;
 def plugin_arg : JoinedAndSeparate<["-"], "plugin-arg-">,
     MetaVarName<"<name> <arg>">,
     HelpText<"Pass <arg> to plugin <name>">;
 def add_plugin : Separate<["-"], "add-plugin">, MetaVarName<"<name>">,
   HelpText<"Use the named plugin action in addition to the default action">,
   MarshallingInfoStringVector<FrontendOpts<"AddPluginActions">>;
 def ast_dump_filter : Separate<["-"], "ast-dump-filter">,
   MetaVarName<"<dump_filter>">,

clang/lib/CodeGen/BackendUtil.cpp

 #define HANDLE_EXTENSION(Ext)                                                  \
   llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
 #include "llvm/Support/Extension.def"
 
 namespace llvm {
 extern cl::opt<bool> DebugInfoCorrelate;
 }
 
+static std::unique_ptr<Module>
+cloneModuleIntoContext(LLVMContext &NewCtx, const Module &M,
+                       bool ShouldPreserveUseListOrder) {
+  SmallVector<char, 0> Buffer;
+  raw_svector_ostream OS(Buffer);
+  WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder);
+  MemoryBufferRef MBuf(OS.str(), "temporary bitcode");
+  Expected<std::unique_ptr<Module>> Module = parseBitcodeFile(MBuf, NewCtx);
+  if (!Module)
+    handleAllErrors(Module.takeError());
+  return std::move(*Module);
+}
+
+static void normalizeModuleForOpaquePointers(Module &M) {
+  for (Function &F : M.functions()) {
+    for (BasicBlock &BB : F) {
+      for (Instruction &I : make_early_inc_range(BB)) {
+        // Drop no-op bitcasts from ptr to ptr, which will not be present
+        // with opaque pointers.
+        if (auto *BC = dyn_cast<BitCastInst>(&I)) {
+          if (BC->getType() == BC->getOperand(0)->getType() &&
+              BC->getType()->isPointerTy()) {
+            BC->replaceAllUsesWith(BC->getOperand(0));
+            BC->eraseFromParent();
+          }
+        }
+      }
+    }
+  }
+}
+
+class NormalizeOpaquePointersPrintModulePass
+    : public PassInfoMixin<PrintModulePass> {
+  raw_ostream &OS;
+  bool ShouldPreserveUseListOrder;
+
+public:
+  NormalizeOpaquePointersPrintModulePass(raw_ostream &OS,
+                                         bool ShouldPreserveUseListOrder)
+      : OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
+
+  PreservedAnalyses run(Module &M, AnalysisManager<Module> &) {
+    if (M.getContext().supportsTypedPointers()) {
+      LLVMContext OpaqueCtx;
+      OpaqueCtx.enableOpaquePointers();
+      std::unique_ptr<Module> OpaqueM =
+          cloneModuleIntoContext(OpaqueCtx, M, ShouldPreserveUseListOrder);
+      normalizeModuleForOpaquePointers(*OpaqueM);
+      OpaqueM->print(OS, nullptr, ShouldPreserveUseListOrder);
+    } else {
+      M.print(OS, nullptr, ShouldPreserveUseListOrder);
+    }
+    return PreservedAnalyses::all();
+  }
+  static bool isRequired() { return true; }
+};
+
 namespace {
 
 // Default filename used for profile generation.
 std::string getDefaultProfileGenName() {
   return DebugInfoCorrelate ? "default_%p.proflite" : "default_%m.profraw";
 }
 
 class EmitAssemblyHelper {
if (CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.DisableLLVMPasses) {
                                    uint32_t(1));
       }
       MPM.addPass(
           BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists, EmitLTOSummary));
     }
     break;
 
   case Backend_EmitLL:
+    if (CodeGenOpts.NormalizeOpaquePointers)
+      MPM.addPass(NormalizeOpaquePointersPrintModulePass(
+          *OS, CodeGenOpts.EmitLLVMUseLists));
+    else
       MPM.addPass(PrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists));
     break;
 
   default:
     break;
   }
 
   // Now that we have all of the passes ready, run them.
   {

clang/test/CodeGenCXX/2009-12-23-MissingSext.cpp

-// RUN: %clang_cc1 %s -triple x86_64-unknown-unknown -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -normalize-opaque-pointers %s -triple x86_64-unknown-unknown -emit-llvm -o - | FileCheck %s
 // The store of p.y into the temporary was not
 // getting extended to 32 bits, so uninitialized
 // bits of the temporary were used.  7366161.
 struct foo {
   char x:8;
   signed int y:24;
 };
 int bar(struct foo p, int x) {
 // CHECK: bar
-// CHECK: %[[val:.*]] = load i32, i32* {{.*}}
+// CHECK: %[[val:.*]] = load i32, ptr {{.*}}
 // CHECK-NEXT:          ashr i32 %[[val]]
-// CHECK:             = load i32, i32* {{.*}}
-// CHECK:             = load i32, i32* {{.*}}
-// CHECK: %[[val:.*]] = load i32, i32* {{.*}}
+// CHECK:             = load i32, ptr {{.*}}
+// CHECK:             = load i32, ptr {{.*}}
+// CHECK: %[[val:.*]] = load i32, ptr {{.*}}
 // CHECK-NEXT:          ashr i32 %[[val]]
   x = (p.y > x ? x : p.y);
   return x;
 // CHECK: ret
 }