X86: Implement null target streamer

[arsenm]

Summary

There should no need for null checks in the AsmPrinter

[MaskRay]

Add a test which this may fix. If MCTargetStreamer is not used (e.g. always guarded by a if-nullptr check), createX86NullTargetStreamer is not needed.

[arsenm]

Add test

[MaskRay]

clang/test/Misc/x86-emit-codegen-only.c

5

This should use a llvm/test/MC or llvm/test/CodeGen test.

[RKSimon]

llvm/lib/Target/X86/MCTargetDesc/X86TargetStreamer.h

41

Why not create a X86TargetNullStreamer class and keep X86TargetStreamer as it is?

[arsenm]

Move test

[arsenm]

llvm/lib/Target/X86/MCTargetDesc/X86TargetStreamer.h

41

That's a lot of extra boilerplate to do nothing

[RKSimon]

llvm/lib/Target/X86/MCTargetDesc/X86TargetStreamer.h

41

OK - I see WebAssemblyTargetNullStreamer does override but I don't think its vital.

[arsenm]

ea9dc0ec3461160acb98a0e3dd668d7f3eef0604

clang/test/Misc/x86-emit-codegen-only.c

+// REQUIRES: x86-registered-target
+// RUN: %clang_cc1 -triple i386-pc-win32 -gcodeview -debug-info-kind=standalone -emit-codegen-only %s
+
+// TargetStreamer is used in emitFunctionBodyStart/emitFunctionBodyEnd for codeview.
+void foo() {}

llvm/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

 //===----------------------------------------------------------------------===//
 
 #include "X86MCTargetDesc.h"
 #include "TargetInfo/X86TargetInfo.h"
 #include "X86ATTInstPrinter.h"
 #include "X86BaseInfo.h"
 #include "X86IntelInstPrinter.h"
 #include "X86MCAsmInfo.h"
+#include "X86TargetStreamer.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
for (Target *T : {&getTheX86_32Target(), &getTheX86_64Target()}) {
 
     // Register the obj target streamer.
     TargetRegistry::RegisterObjectTargetStreamer(*T,
                                                  createX86ObjectTargetStreamer);
 
     // Register the asm target streamer.
     TargetRegistry::RegisterAsmTargetStreamer(*T, createX86AsmTargetStreamer);
 
+    // Register the null streamer.
+    TargetRegistry::RegisterNullTargetStreamer(*T, createX86NullTargetStreamer);
+
     TargetRegistry::RegisterCOFFStreamer(*T, createX86WinCOFFStreamer);
 
     // Register the MCInstPrinter.
     TargetRegistry::RegisterMCInstPrinter(*T, createX86MCInstPrinter);
 
     // Register the MC relocation info.
     TargetRegistry::RegisterMCRelocationInfo(*T, createX86MCRelocationInfo);
   }

llvm/lib/Target/X86/MCTargetDesc/X86TargetStreamer.h

 namespace llvm {
 
 /// X86 target streamer implementing x86-only assembly directives.
 class X86TargetStreamer : public MCTargetStreamer {
 public:
   X86TargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
 
   virtual bool emitFPOProc(const MCSymbol *ProcSym, unsigned ParamsSize,
-                           SMLoc L = {}) = 0;
-  virtual bool emitFPOEndPrologue(SMLoc L = {}) = 0;
-  virtual bool emitFPOEndProc(SMLoc L = {}) = 0;
-  virtual bool emitFPOData(const MCSymbol *ProcSym, SMLoc L = {}) = 0;
-  virtual bool emitFPOPushReg(unsigned Reg, SMLoc L = {}) = 0;
-  virtual bool emitFPOStackAlloc(unsigned StackAlloc, SMLoc L = {}) = 0;
-  virtual bool emitFPOStackAlign(unsigned Align, SMLoc L = {}) = 0;
-  virtual bool emitFPOSetFrame(unsigned Reg, SMLoc L = {}) = 0;
+                           SMLoc L = {}) {
+    return false;
+  }
+  virtual bool emitFPOEndPrologue(SMLoc L = {}) { return false; }
+  virtual bool emitFPOEndProc(SMLoc L = {}) { return false; };
+  virtual bool emitFPOData(const MCSymbol *ProcSym, SMLoc L = {}) {
+    return false;
+  }
+  virtual bool emitFPOPushReg(unsigned Reg, SMLoc L = {}) { return false; }
+  virtual bool emitFPOStackAlloc(unsigned StackAlloc, SMLoc L = {}) {
+    return false;
+  }
+  virtual bool emitFPOStackAlign(unsigned Align, SMLoc L = {}) { return false; }
+  virtual bool emitFPOSetFrame(unsigned Reg, SMLoc L = {}) { return false; }
 };
 
+/// Implements X86-only null emission.
+inline MCTargetStreamer *createX86NullTargetStreamer(MCStreamer &S) {
+  return new X86TargetStreamer(S);
+}
+
 } // end namespace llvm
 
 #endif

llvm/lib/Target/X86/X86AsmPrinter.cpp

bool X86AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
   IndCSPrefix = false;
 
   // We didn't modify anything.
   return false;
 }
 
 void X86AsmPrinter::emitFunctionBodyStart() {
   if (EmitFPOData) {
-    if (auto *XTS =
-        static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
-      XTS->emitFPOProc(
-          CurrentFnSym,
-          MF->getInfo<X86MachineFunctionInfo>()->getArgumentStackSize());
+    auto *XTS =
+        static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer());
   }
 }
 
 void X86AsmPrinter::emitFunctionBodyEnd() {
   if (EmitFPOData) {
-    if (auto *XTS =
-            static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
-      XTS->emitFPOEndProc();
+    auto *XTS =
+        static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer());
   }
 }
 
 uint32_t X86AsmPrinter::MaskKCFIType(uint32_t Value) {
   // If the type hash matches an invalid pattern, mask the value.
   const uint32_t InvalidValues[] = {
       0xFA1E0FF3, /* ENDBR64 */
       0xFB1E0FF3, /* ENDBR32 */