[cfe][inline-asm] Support target-specific escaped character in inline asm

[myhsu]

Summary

GCC allows each target to define a set of non-letter and non-digit escaped characters for inline assembly that will be replaced by another string (They call this "punctuation" characters. The existing "%%" and "%{" -- replaced by '%' and '{' at the end -- can be seen as special cases shared by all targets).
This patch implements this feature by adding a new hook in TargetInfo.

Updated: In case you wonder, this is a list of supported punctuation chars for i386 in GCC.
And these are punctuations for M68k.

[nickdesaulniers]

clang/include/clang/Basic/TargetInfo.h

1094–1095

Use triple slashes so that a Doxygen comment can be produced. End sentence with a period.

clang/lib/AST/Stmt.cpp

671

Terminate sentence with period.

671–675

Do you want to move this addition into the default case above?

[nickdesaulniers]

LGTM; please fix up minor nits. Thanks for the patch!

[myhsu]

Fix formatting

clang/include/clang/Basic/TargetInfo.h

public:
   // constraint is longer than one character.
   virtual std::string convertConstraint(const char *&Constraint) const {
     // 'p' defaults to 'r', but can be overridden by targets.
     if (*Constraint == 'p')
       return std::string("r");
     return std::string(1, *Constraint);
   }
 
+  // Replace some escaped characters with another string based on
+  // target-specific rules
+  virtual llvm::Optional<std::string> handleAsmEscapedChar(char C) const {
+    return llvm::None;
+  }
+
   /// Returns a string of target-specific clobbers, in LLVM format.
   virtual const char *getClobbers() const = 0;
 
   /// Returns true if NaN encoding is IEEE 754-2008.
   /// Only MIPS allows a different encoding.
   virtual bool isNan2008() const {
     return true;
   }

clang/lib/AST/Stmt.cpp

while (true) {
     case '}': CurStringPiece += (HasVariants ? "$)" : "}"); continue;
     case '%':
       break;
     default:
       CurStringPiece += CurChar;
       continue;
     }
 
+    const TargetInfo &TI = C.getTargetInfo();
+
     // Escaped "%" character in asm string.
     if (CurPtr == StrEnd) {
       // % at end of string is invalid (no escape).
       DiagOffs = CurPtr-StrStart-1;
       return diag::err_asm_invalid_escape;
     }
     // Handle escaped char and continue looping over the asm string.
     char EscapedChar = *CurPtr++;
     switch (EscapedChar) {
     default:
       break;
     case '%': // %% -> %
     case '{': // %{ -> {
     case '}': // %} -> }
       CurStringPiece += EscapedChar;
       continue;
     case '=': // %= -> Generate a unique ID.
       CurStringPiece += "${:uid}";
       continue;
     }
+    // Handle target-specific escaped characters
+    if (auto MaybeReplaceStr = TI.handleAsmEscapedChar(EscapedChar)) {
+      CurStringPiece += *MaybeReplaceStr;
+      continue;
+    }
 
     // Otherwise, we have an operand.  If we have accumulated a string so far,
     // add it to the Pieces list.
     if (!CurStringPiece.empty()) {
       Pieces.push_back(AsmStringPiece(CurStringPiece));
       CurStringPiece.clear();
     }
 
     // Handle operands that have asmSymbolicName (e.g., %x[foo]) and those that
     // don't (e.g., %x4). 'x' following the '%' is the constraint modifier.
 
     const char *Begin = CurPtr - 1; // Points to the character following '%'.
     const char *Percent = Begin - 1; // Points to '%'.
 
     if (isLetter(EscapedChar)) {
       if (CurPtr == StrEnd) { // Premature end.
         DiagOffs = CurPtr-StrStart-1;
         return diag::err_asm_invalid_escape;
       }
       EscapedChar = *CurPtr++;
     }
 
-    const TargetInfo &TI = C.getTargetInfo();
     const SourceManager &SM = C.getSourceManager();
     const LangOptions &LO = C.getLangOpts();
 
     // Handle operands that don't have asmSymbolicName (e.g., %x4).
     if (isDigit(EscapedChar)) {
       // %n - Assembler operand n
       unsigned N = 0;
 

clang/lib/Basic/Targets/M68k.h

void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
   bool hasFeature(StringRef Feature) const override;
   ArrayRef<const char *> getGCCRegNames() const override;
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
   std::string convertConstraint(const char *&Constraint) const override;
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &info) const override;
+  llvm::Optional<std::string> handleAsmEscapedChar(char EscChar) const override;
   const char *getClobbers() const override;
   BuiltinVaListKind getBuiltinVaListKind() const override;
   bool setCPU(const std::string &Name) override;
 };
 
 } // namespace targets
 } // namespace clang
 
 #endif

clang/lib/Basic/Targets/M68k.cpp

case 'C':
     }
     break;
   default:
     break;
   }
   return false;
 }
 
+llvm::Optional<std::string>
+M68kTargetInfo::handleAsmEscapedChar(char EscChar) const {
+  char C;
+  switch (EscChar) {
+  case '.':
+  case '#':
+    C = EscChar;
+    break;
+  case '/':
+    C = '%';
+    break;
+  case '$':
+    C = 's';
+    break;
+  case '&':
+    C = 'd';
+    break;
+  default:
+    return llvm::None;
+  }
+
+  return std::string(1, C);
+}
+
 std::string M68kTargetInfo::convertConstraint(const char *&Constraint) const {
   if (*Constraint == 'C')
     // Two-character constraint; add "^" hint for later parsing
     return std::string("^") + std::string(Constraint++, 2);
 
   return std::string(1, *Constraint);
 }
 

clang/test/CodeGen/m68k-asm.c

+// REQUIRES: m68k-registered-target
+// RUN: %clang -target m68k -S %s -o - | FileCheck %s
+
+// Test special escaped character in inline assembly
+void escaped() {
+  // '.' -> '.'
+  // CHECK: move.l #66, %d1
+  __asm__ ("move%.l #66, %%d1" ::);
+  // '#' -> '#'
+  // CHECK: move.l #66, %d1
+  __asm__ ("move.l %#66, %%d1" ::);
+  // '/' -> '%'
+  // CHECK: move.l #66, %d1
+  __asm__ ("move.l #66, %/d1" ::);
+  // '$' -> 's'
+  // CHECK: muls %d0, %d1
+  __asm__ ("mul%$ %%d0, %%d1" ::);
+  // '&' -> 'd'
+  // CHECK: move.l %d0, %d1
+  __asm__ ("move.l %%%&0, %%d1" ::);
+}