[MC] Support .ds directives in assembler parser

[phosek]

Summary

These directives are already supported by GNU assembler.

[davide]

Some comments, hope you don't mind :)

lib/MC/MCParser/AsmParser.cpp

1919–1934

you can probably merge DK_DS_X and DK_DS_P cases (and you can do similarly for others, i.e.

case DK_DS_X:
case DK_DS_P:
  return ...

4244–4245

Do you want to emit a diagnostic here?

4248–4249

Please add a test for this case.

4252–4254

and this one.

[davide]

this looks good after my first round of comments. Thanks

[phosek]

The patch was rebased.

lib/MC/MCParser/AsmParser.cpp

private:
 
   // Generic (target and platform independent) directive parsing.
   enum DirectiveKind {
     DK_NO_DIRECTIVE, // Placeholder
     DK_SET, DK_EQU, DK_EQUIV, DK_ASCII, DK_ASCIZ, DK_STRING, DK_BYTE, DK_SHORT,
     DK_RELOC,
     DK_VALUE, DK_2BYTE, DK_LONG, DK_INT, DK_4BYTE, DK_QUAD, DK_8BYTE, DK_OCTA,
     DK_DC, DK_DC_A, DK_DC_B, DK_DC_D, DK_DC_L, DK_DC_S, DK_DC_W, DK_DC_X,
+    DK_DS, DK_DS_B, DK_DS_D, DK_DS_L, DK_DS_P, DK_DS_S, DK_DS_W, DK_DS_X,
     DK_SINGLE, DK_FLOAT, DK_DOUBLE, DK_ALIGN, DK_ALIGN32, DK_BALIGN, DK_BALIGNW,
     DK_BALIGNL, DK_P2ALIGN, DK_P2ALIGNW, DK_P2ALIGNL, DK_ORG, DK_FILL, DK_ENDR,
     DK_BUNDLE_ALIGN_MODE, DK_BUNDLE_LOCK, DK_BUNDLE_UNLOCK,
     DK_ZERO, DK_EXTERN, DK_GLOBL, DK_GLOBAL,
     DK_LAZY_REFERENCE, DK_NO_DEAD_STRIP, DK_SYMBOL_RESOLVER,
     DK_PRIVATE_EXTERN, DK_REFERENCE, DK_WEAK_DEFINITION, DK_WEAK_REFERENCE,
     DK_WEAK_DEF_CAN_BE_HIDDEN, DK_COMM, DK_COMMON, DK_LCOMM, DK_ABORT,
     DK_INCLUDE, DK_INCBIN, DK_CODE16, DK_CODE16GCC, DK_REPT, DK_IRP, DK_IRPC,
private:
   // ".bundle_lock"
   bool parseDirectiveBundleLock();
   // ".bundle_unlock"
   bool parseDirectiveBundleUnlock();
 
   // ".space", ".skip"
   bool parseDirectiveSpace(StringRef IDVal);
 
+  // ".ds"
+  bool parseDirectiveDS(StringRef IDVal, unsigned Size);
+
   // .sleb128 (Signed=true) and .uleb128 (Signed=false)
   bool parseDirectiveLEB128(bool Signed);
 
   /// \brief Parse a directive like ".globl" which
   /// accepts a single symbol (which should be a label or an external).
   bool parseDirectiveSymbolAttribute(MCSymbolAttr Attr);
 
   bool parseDirectiveComm(bool IsLocal); // ".comm" and ".lcomm"
case DK_DC_L:
       return parseDirectiveValue(4);
     case DK_DC_S:
       return parseDirectiveRealValue(APFloat::IEEEsingle);
     case DK_DC_W:
       return parseDirectiveValue(2);
     case DK_DC_X:
       return TokError(Twine(IDVal) +
                       " not currently supported for this target");
+    case DK_DS:
+      return parseDirectiveDS(IDVal, 2);
+    case DK_DS_B:
+      return parseDirectiveDS(IDVal, 1);
+    case DK_DS_D:
+      return parseDirectiveDS(IDVal, 8);
+    case DK_DS_L:
+      return parseDirectiveDS(IDVal, 4);
+    case DK_DS_P:
+      return parseDirectiveDS(IDVal, 12);
+    case DK_DS_S:
+      return parseDirectiveDS(IDVal, 4);
+    case DK_DS_W:
+      return parseDirectiveDS(IDVal, 2);
+    case DK_DS_X:
+      return parseDirectiveDS(IDVal, 12);
     }
 
     return Error(IDLoc, "unknown directive");
   }
 
   // __asm _emit or __asm __emit
   if (ParsingInlineAsm && (IDVal == "_emit" || IDVal == "__emit" ||
                            IDVal == "_EMIT" || IDVal == "__EMIT"))
if (parseToken(AsmToken::EndOfStatement,
     return true;
 
   // FIXME: Sometimes the fill expr is 'nop' if it isn't supplied, instead of 0.
   getStreamer().emitFill(*NumBytes, FillExpr, NumBytesLoc);
 
   return false;
 }
 
+/// parseDirectiveDS
+/// ::= .ds.{b, d, l, p, s, w, x} expression
+bool AsmParser::parseDirectiveDS(StringRef IDVal, unsigned Size) {
+  checkForValidSection();
+
+  SMLoc NumValuesLoc = Lexer.getLoc();
+  int64_t NumValues;
+  if (parseAbsoluteExpression(NumValues))
+    return true;
+
+  if (NumValues < 0) {
+    Warning(NumValuesLoc, "'" + Twine(IDVal) + "' directive with negative repeat count has no effect");
+    return false;
+  }
+
+  if (parseToken(AsmToken::EndOfStatement,
+                 "unexpected token in '" + Twine(IDVal) + "' directive"))
+    return true;
+
+  for (uint64_t i = 0, e = NumValues; i != e; ++i)
+    getStreamer().emitFill(Size, 0);
+
+  return false;
+}
+
 /// parseDirectiveLEB128
 /// ::= (.sleb128 | .uleb128) [ expression (, expression)* ]
 bool AsmParser::parseDirectiveLEB128(bool Signed) {
   checkForValidSection();
   const MCExpr *Value;
 
   while (true) {
     if (parseExpression(Value))
void AsmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".dc"] = DK_DC;
   DirectiveKindMap[".dc.a"] = DK_DC_A;
   DirectiveKindMap[".dc.b"] = DK_DC_B;
   DirectiveKindMap[".dc.d"] = DK_DC_D;
   DirectiveKindMap[".dc.l"] = DK_DC_L;
   DirectiveKindMap[".dc.s"] = DK_DC_S;
   DirectiveKindMap[".dc.w"] = DK_DC_W;
   DirectiveKindMap[".dc.x"] = DK_DC_X;
+  DirectiveKindMap[".ds"] = DK_DS;
+  DirectiveKindMap[".ds.b"] = DK_DS_B;
+  DirectiveKindMap[".ds.d"] = DK_DS_D;
+  DirectiveKindMap[".ds.l"] = DK_DS_L;
+  DirectiveKindMap[".ds.p"] = DK_DS_P;
+  DirectiveKindMap[".ds.s"] = DK_DS_S;
+  DirectiveKindMap[".ds.w"] = DK_DS_W;
+  DirectiveKindMap[".ds.x"] = DK_DS_X;
 }
 
 MCAsmMacro *AsmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
   AsmToken EndToken, StartToken = getTok();
 
   unsigned NestLevel = 0;
   while (true) {
     // Check whether we have reached the end of the file.

test/MC/AsmParser/directive_ds.s

+# RUN: llvm-mc -triple i386-unknown-unknown %s | FileCheck %s
+
+# CHECK: TEST0:
+# CHECK: .zero 1
+TEST0:
+        .ds.b 1
+
+# CHECK: TEST1:
+# CHECK: .zero 2
+# CHECK: .zero 2
+# CHECK: .zero 2
+TEST1:
+        .ds 3
+
+# CHECK: TEST2:
+TEST2:
+        .ds.w 0
+
+# CHECK: TEST3:
+# CHECK: .zero 4
+# CHECK: .zero 4
+TEST3:
+        .ds.l 2
+
+# CHECK: TEST4:
+# CHECK: .zero 8
+# CHECK: .zero 8
+# CHECK: .zero 8
+# CHECK: .zero 8
+TEST4:
+        .ds.d 4
+
+# CHECK: TEST5:
+# CHECK: .zero 12
+# CHECK: .zero 12
+TEST5:
+        .ds.p 2
+
+# CHECK: TEST6:
+# CHECK: .zero 4
+# CHECK: .zero 4
+# CHECK: .zero 4
+TEST6:
+        .ds.s 3
+
+# CHECK: TEST7:
+# CHECK: .zero 12
+TEST7:
+        .ds.x 1