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

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

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

lib/Target/X86/X86AsmPrinter.cpp

67

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

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

A newline before this line would be nice.

7

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.

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);
 

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";
+}
 
 void MCAsmStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
   OS << "\t.def\t ";
   Symbol->print(OS, MAI);
   OS << ';';
   EmitEOL();
 }
 

lib/MC/MCStreamer.cpp

if (Except)
     CurrentWinFrameInfo->HandlesExceptions = true;
 }
 
 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);

lib/Target/X86/X86AsmPrinter.cpp

bool X86AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
 
   if (Subtarget->isTargetCOFF()) {
     bool Intrn = MF.getFunction()->hasInternalLinkage();
     OutStreamer->BeginCOFFSymbolDef(CurrentFnSym);
     OutStreamer->EmitCOFFSymbolStorageClass(Intrn ? COFF::IMAGE_SYM_CLASS_STATIC
                                             : COFF::IMAGE_SYM_CLASS_EXTERNAL);
     OutStreamer->EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION
                                                << COFF::SCT_COMPLEX_TYPE_SHIFT);
+    OutStreamer->EmitSyntaxDirective();
     OutStreamer->EndCOFFSymbolDef();
   }
-
+  else
+    OutStreamer->EmitSyntaxDirective();
   // Emit the rest of the function body.
   EmitFunctionBody();
 
   // We didn't modify anything.
   return false;
 }
 
 /// printSymbolOperand - Print a raw symbol reference operand.  This handles

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

+; RUN: llc -x86-asm-syntax=intel < %s | FileCheck %s
+; CHECK: .intel_syntax noprefix
+define i32 @test(i32 %a) {
+entry:
+;   CHECK-LABEL: test:
+  %tmp3 = mul i32 %a, 31
+  ret i32 %tmp3
+}