add .intel_syntax noprefix print to llvm

[m_zuckerman]

Summary

This for printing .intel_syntax noprefix.
In clang there is two type of print asm by at&t and intel_syntax.
clang support the intel_syntax without the print directive .
Now clang print to asm file directive

[compnerd]

The directive is "intel_syntax", not "intel_syntax noprefix". noprefix is an optional argument.

The intel and AT&T formats aren't clang specific. Both of them are pretty common x86 conventions. Intel is the one that intel defined, and AT&T is the one that GNU uses. The former is the standard, the latter is needed for compatibility with GCC, and so clang needs both. I think that the commit message is somewhat misleading.

lib/MC/MCAsmStreamer.cpp

485 ↗

(On Diff #29786)

Can you add a FIXME here indicating that we currently emit unprefix'ed registers, and that this should be controllable? The intel_syntax directive has 1 optional argument which may have a value of prefix or noprefix indicating whether registers have the % prefix or not.

lib/MC/MCStreamer.cpp

469 ↗

(On Diff #29786)

Missing space between ) and {. Perhaps you should clang-format the diff?

lib/Target/X86/X86AsmPrinter.cpp

67 ↗

(On Diff #29786)

Can't the EmitSyntaxDirective invocation be hoisted? Why emit the intel_syntax directive after each function header?

test/MC/X86/intel-syntax-print.ll

1 ↗

(On Diff #29786)

How about a negative test case? Something along the lines of:

; RUN: llc -x86-asm-syntax=gnu %s | FileCheck -check-prefix CHECK-GNU %s

; CHECK-GNU-NOT: .intel_syntax

2 ↗

(On Diff #29786)

A newline before this line would be nice.

7 ↗

(On Diff #29786)

I think you could further simplify the test case:

define i32 @test() {
entry:
  ret i32 0
}

You are just interested in the syntax header being present.

[compnerd]

Merge the two tests into a single file. You can have multiple RUN commands in a single file. You can also pass -check-prefix parameters to check to ensure that the checks don't get mixed up. Looks good otherwise.

llvm/trunk/include/llvm/MC/MCStreamer.h

public:
   virtual void EmitWinCFISaveReg(unsigned Register, unsigned Offset);
   virtual void EmitWinCFISaveXMM(unsigned Register, unsigned Offset);
   virtual void EmitWinCFIPushFrame(bool Code);
   virtual void EmitWinCFIEndProlog();
 
   virtual void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except);
   virtual void EmitWinEHHandlerData();
 
+  virtual void EmitSyntaxDirective();
+
   /// \brief Emit the given \p Instruction into the current section.
   virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
 
   /// \brief Set the bundle alignment mode from now on in the section.
   /// The argument is the power of 2 to which the alignment is set. The
   /// value 0 means turn the bundle alignment off.
   virtual void EmitBundleAlignMode(unsigned AlignPow2);
 

llvm/trunk/lib/MC/MCAsmStreamer.cpp

public:
   inline void EmitEOL() {
     // If we don't have any comments, just emit a \n.
     if (!IsVerboseAsm) {
       OS << '\n';
       return;
     }
     EmitCommentsAndEOL();
   }
+
+  virtual void EmitSyntaxDirective();
+
   void EmitCommentsAndEOL();
 
   /// isVerboseAsm - Return true if this streamer supports verbose assembly at
   /// all.
   bool isVerboseAsm() const override { return IsVerboseAsm; }
 
   /// hasRawTextSupport - We support EmitRawText.
   bool hasRawTextSupport() const override { return true; }

 
 void MCAsmStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
   OS << ".desc" << ' ';
   Symbol->print(OS, MAI);
   OS << ',' << DescValue;
   EmitEOL();
 }
 
+void MCAsmStreamer::EmitSyntaxDirective() {
+  if (MAI->getAssemblerDialect() == 1)
+    OS << "\t.intel_syntax noprefix\n";
+  // FIXME: Currently emit unprefix'ed registers.
+  // The intel_syntax directive has one optional argument 
+  // with may have a value of prefix or noprefix.
+}
+
 void MCAsmStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
   OS << "\t.def\t ";
   Symbol->print(OS, MAI);
   OS << ';';
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitCOFFSymbolStorageClass (int StorageClass) {

llvm/trunk/lib/MC/MCStreamer.cpp

 }
 
 void MCStreamer::EmitWinEHHandlerData() {
   EnsureValidWinFrameInfo();
   if (CurrentWinFrameInfo->ChainedParent)
     report_fatal_error("Chained unwind areas can't have handlers!");
 }
 
+void MCStreamer::EmitSyntaxDirective() {}
+
 void MCStreamer::EmitWinCFIPushReg(unsigned Register) {
   EnsureValidWinFrameInfo();
 
   MCSymbol *Label = getContext().createTempSymbol();
   EmitLabel(Label);
 
   WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
   CurrentWinFrameInfo->Instructions.push_back(Inst);

llvm/trunk/lib/Target/X86/X86AsmPrinter.cpp

if (TT.getArch() == Triple::x86) {
       // must be registered in .sxdata.  Use of any unregistered handlers will
       // cause the process to terminate immediately.  LLVM does not know how to
       // register any SEH handlers, so its object files should be safe.
       OutStreamer->EmitSymbolAttribute(S, MCSA_Global);
       OutStreamer->EmitAssignment(
           S, MCConstantExpr::create(int64_t(1), MMI->getContext()));
     }
   }
+  OutStreamer->EmitSyntaxDirective();
 }
 
 static void
 emitNonLazySymbolPointer(MCStreamer &OutStreamer, MCSymbol *StubLabel,
                          MachineModuleInfoImpl::StubValueTy &MCSym) {
   // L_foo$stub:
   OutStreamer.EmitLabel(StubLabel);
   //   .indirect_symbol _foo

llvm/trunk/test/MC/X86/intel-syntax-print.ll

+; RUN: llc -x86-asm-syntax=intel < %s | FileCheck %s -check-prefix=INTEL
+; RUN: llc -x86-asm-syntax=att < %s | FileCheck %s -check-prefix=ATT
+
+; INTEL: .intel_syntax noprefix
+; ATT-NOT: .intel_syntax noprefix
+define i32 @test() {
+entry:
+  ret i32 0
+}