[MC] Support symbolic expressions in assembly directives

[phosek]

Summary

This matches the behavior of GNU assembler which supports symbolic expressions in absolute expressions used in assembly directives.

[• rafael]

What happens if you try to print the assembly back out? I.e., if you run
llvm-mc with filetype=obj?

Cheers,
Rafael

[• rafael]

I mean filetype=asm :-)

[phosek]

That would currently trigger an error error: expected absolute expression since MCAsmStreamer doesn't currently have any layout information. Is this something you would like to support as well?

[jyknight]

In D20337#433834, @phosek wrote:

That would currently trigger an error error: expected absolute expression since MCAsmStreamer doesn't currently have any layout information. Is this something you would like to support as well?

Yes, I think supporting this is necessary, since "clang -S foo.c" requires exactly that (on platforms that use the integrated assembler).

I think to make that work, everything in AsmParser that currently uses parseAbsoluteExpression/evaluateAsAbsolute will need to be switched to parsing an arbitrary expression, and passing it on to MCStreamer as-is without evaluating. MCObjectStreamer can then assert that you've only given it an absolute expression, and evaluate it. MCAsmStreamer would just emit the expression as-is for the final assembler to deal with.

For many directives, that wouldn't be too bad. ".zero", for example. You can just add an MCStreamer::EmitFill taking two expressions, instead of two integers, and change AsmParser to call that version.

For others, that actually do something with the value other than error-check it and pass it through, it'll be somewhat more complex.

[phosek]

That was the alternative design that I was originally considering but I wanted to start with something simpler. I'll give it a try and see how complicated it's going to be.

[niravd]

If we are deferring on error reporting past the current compile, we should
emit line number directives for the user.
niravd added a subscriber: niravd.

Repository:

rL LLVM

http://reviews.llvm.org/D20337

[jyknight]

In D20337#434903, @phosek wrote:

That was the alternative design that I was originally considering but I wanted to start with something simpler. I'll give it a try and see how complicated it's going to be.

BTW, I'd certainly recommend trying to hande only a subset of the directives. E.g. supporting the align/fill types of things, but avoiding really complex beasts ".if", ".rept", and such.

[phosek]

I have updated the implementation to follow the proposed approach. So far I've only implemented support for .fill, .skip, .space and .zero. I was also considering supporting .align, but this directive is a little more special due to various restrictions on various platforms and I'm not sure if the symbolic expression are actually being used in combination with .align. I have also restricted the symbolic expression support to the first argument which is the size, it might be possible to support them in other arguments as well (GNU assembler does), but again I'm not sure how useful that would be.

[niravd]

include/llvm/MC/MCStreamer.h

591 ↗

(On Diff #58170)

Please rename to match casing of other Emit functions. (EmitSpace).

602 ↗

(On Diff #58170)

Why isn't this named EmitFill? It's of a distinct type from the other calls and is only for dealing with Fill directives and the distinction seems more confusing than multiple variants of EmitFill.

605 ↗

(On Diff #58170)

Save as above.

lib/MC/MCAsmStreamer.cpp

828 ↗

(On Diff #58170)

Since we cannot guarantee a lack of errors at this point we should emit line directives before and after this so that we preserve the error message location with respect to the original file.

lib/MC/MCParser/AsmParser.cpp

2749 ↗

(On Diff #58170)

Please decompose this into parseExpression and evaluateAsAbsolute to distinguish expression structure errors (should throw an error here) from value errors which we may defer.

[phosek]

include/llvm/MC/MCStreamer.h

602 ↗

(On Diff #58170)

EmitFill is used for emitting "fill bytes" in case of directives like .space and .zero while .fill requires a special handling. I could rename both emitSpace and emitRepeatedValue to EmitFill if you prefer since it's distinct type from the other one, I just wanted to avoid confusion, but I feel like it's going to be confusing in either case.

[• rafael]

lib/MC/MCAsmStreamer.cpp

823 ↗

(On Diff #58170)

You don't need to this in the asm streamer. My suggestion would be to just make this a variant of emitFill. We would have one overload that takes a number and one that takes an expression. The implementations would be:

• In the asm streamer: the ones taking an MCExpr does the printing. The other one creates an MCExpr and forwards.
• In the obj streamer: what you have now. Try to evaluate the expr and maybe fail. If it works, forward to the overload that takes a number.

[phosek]

lib/MC/MCAsmStreamer.cpp

823 ↗

(On Diff #58170)

In case of MCAsmStreamer, where would we evaluate the MCExpr expression then? Does it mean we should always print out the expression even if it's absolute?

[phosek]

Should this be limited only to the .space case or .fill as well? The
.fill implementation currently emits multiple directives in the constant
case, we could instead just emit .fill directive so it's the same both in
absolute and symbol case, but that means we'd have to change the current
behavior, is that fine with you?

[phosek]

The updated patch implements the requested changes. The biggest difference is that we no longer perform evaluation for .fill and .skip/.space/.zero directives and even in the absolute case defer to the symbol version following Rafael's suggestion.

[phosek]

include/llvm/MC/MCStreamer.h

591 ↗

(On Diff #58170)

I'm following the new convention rather than existing casing. I can rename the remaining Emit* functions in a separate patch.

lib/MC/MCAsmStreamer.cpp

828 ↗

(On Diff #58170)

This should no longer be necessary as the error handling case below has been fixed.

lib/MC/MCParser/AsmParser.cpp

2749 ↗

(On Diff #58170)

This was a leftover from the previous version, I've reverted this case to the original version.

[niravd]

lib/MC/MCAsmStreamer.cpp

828 ↗

(On Diff #58379)

I believe it still is. Consider the case where the symbolic expression emitted for NumBytes is eventually evaluated to a non-positive number or is invalid? Errors in the compilation of the output assembly would point to location in the output asm file not the original as it should.

[• rafael]

LGTM with nits.

I think the interface can be simplified further, but that should be a follow up. What I think should be done in another patch is to make the versions that take an integer be non virtual and just create and forward to the version that takes an expression.

include/llvm/MC/MCObjectStreamer.h

144 ↗

(On Diff #58379)

NumBytes can be a reference, no?

include/llvm/MC/MCStreamer.h

584 ↗

(On Diff #58379)

Size is not a parameter of this version, nor is Value.

595 ↗

(On Diff #58379)

This don't match the signature.

lib/MC/MCAsmStreamer.cpp

828 ↗

(On Diff #58379)

This is the asm streamer, so it will just print a negative number in the .s.

831 ↗

(On Diff #58379)

git-clang-format the patch

[niravd]

lib/MC/MCAsmStreamer.cpp

828 ↗

(On Diff #58379)

That's not the case that I'm concerned about.

Let's say it's an expression (TEST1 - TEST0 - 4) for which we don't know should cause an error until we generate an object. With this we will to output this to the file without checking. If it's a problem, we will absolutely error when we attempt to generate an object but we've lost the original location of the error and we'll instead get the location from the new file which we do not gaurantee to be the same.

This breaks the property that generating an assembly and then making an object file has the same output as just generating the object file directly.

[• rafael]

That's not the case that I'm concerned about.

Let's say it's an expression (TEST1 - TEST0 - 4) for which we don't know should cause an error until we generate an object. With this we will to output this to the file without checking. If it's a problem, we will absolutely error when we attempt to generate an object but we've lost the original location of the error and we'll instead get the location from the new file which we do not gaurantee to be the same.

For the sake of argument lets say it is clang creating that expression.

If someone is running "clang -S test.c && clang -c test.s" we will
report an error in the .s. There is no way around it: the .s doesn't
have a way to cary the location for use in the error message.

If someone is running "clang -c test.c" we will not use the asm streamer.

This breaks the property that generating an assembly and then making an object file has the same output as just generating the object file directly.

If there is no error, that property is not broken.
If there is an error, that property doesn't exist already. It is
perfectly possible to create a .s that will not assemble.

If there is the desire to change that, what I think should happen is
for -S to create and discard an object file in memory. Without
creating an actual assembler we will never know for sure if a .s can
or cannot be assembled, but that is independent from this change.

Cheers,
Rafael

[jyknight]

Just testing phabricator. (it seems to have ignored the previous responses
in this thread; not sure why)

[phosek]

I've addressed issues pointed by Rafael and added FIXME comments about the location directives.

[• rafael]

The formating still looks funny. There are returns in the same line as
ifs, which I don't think clang format produces.

[phosek]

The formatting should be fixed now, seems like git-clang-format picked up a wrong style when I ran it before.

[• rafael]

LGTM

llvm/trunk/include/llvm/MC/MCObjectStreamer.h

void EmitCVDefRangeDirective(
       StringRef FixedSizePortion) override;
   void EmitCVStringTableDirective() override;
   void EmitCVFileChecksumsDirective() override;
   void EmitGPRel32Value(const MCExpr *Value) override;
   void EmitGPRel64Value(const MCExpr *Value) override;
   bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
                           const MCExpr *Expr, SMLoc Loc) override;
   void EmitFill(uint64_t NumBytes, uint8_t FillValue) override;
+  void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
+                SMLoc Loc = SMLoc()) override;
+  void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
+                SMLoc Loc = SMLoc()) override;
+
   void FinishImpl() override;
 
   /// Emit the absolute difference between two symbols if possible.
   ///
   /// Emit the absolute difference between \c Hi and \c Lo, as long as we can
   /// compute it.  Currently, that requires that both symbols are in the same
   /// data fragment.  Otherwise, do nothing and return \c false.
   ///

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

public:
   /// This is used to implement assembler directives such as .gprel32 on
   /// targets that support them.
   virtual void EmitGPRel32Value(const MCExpr *Value);
 
   /// \brief Emit NumBytes bytes worth of the value specified by FillValue.
   /// This implements directives such as '.space'.
   virtual void EmitFill(uint64_t NumBytes, uint8_t FillValue);
 
+  /// \brief Emit \p Size bytes worth of the value specified by \p FillValue.
+  ///
+  /// This is used to implement assembler directives such as .space or .skip.
+  ///
+  /// \param NumBytes - The number of bytes to emit.
+  /// \param FillValue - The value to use when filling bytes.
+  /// \param Loc - The location of the expression for error reporting.
+  virtual void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
+                        SMLoc Loc = SMLoc());
+
+  /// \brief Emit \p NumValues copies of \p Size bytes. Each \p Size bytes is
+  /// taken from the lowest order 4 bytes of \p Expr expression.
+  ///
+  /// This is used to implement assembler directives such as .fill.
+  ///
+  /// \param NumValues - The number of copies of \p Size bytes to emit.
+  /// \param Size - The size (in bytes) of each repeated value.
+  /// \param Expr - The expression from which \p Size bytes are used.
+  virtual void emitFill(uint64_t NumValues, int64_t Size, int64_t Expr);
+  virtual void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
+                        SMLoc Loc = SMLoc());
+
   /// \brief Emit NumBytes worth of zeros.
   /// This function properly handles data in virtual sections.
   void EmitZeros(uint64_t NumBytes);
 
   /// \brief Emit some number of copies of \p Value until the byte alignment \p
   /// ByteAlignment is reached.
   ///
   /// If the number of bytes need to emit for the alignment is not a multiple

llvm/trunk/lib/MC/MCAsmStreamer.cpp

 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/SourceMgr.h"
 #include <cctype>
 
 using namespace llvm;
 
 namespace {
 
 class MCAsmStreamer final : public MCStreamer {
   std::unique_ptr<formatted_raw_ostream> OSOwner;
public:
 
   void EmitGPRel64Value(const MCExpr *Value) override;
 
   void EmitGPRel32Value(const MCExpr *Value) override;
 
 
   void EmitFill(uint64_t NumBytes, uint8_t FillValue) override;
 
+  void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
+                SMLoc Loc = SMLoc()) override;
+
+  void emitFill(uint64_t NumValues, int64_t Size, int64_t Expr) override;
+
+  void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
+                SMLoc Loc = SMLoc()) override;
+
   void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
                             unsigned ValueSize = 1,
                             unsigned MaxBytesToEmit = 0) override;
 
   void EmitCodeAlignment(unsigned ByteAlignment,
                          unsigned MaxBytesToEmit = 0) override;
 
   void emitValueToOffset(const MCExpr *Offset,
void MCAsmStreamer::EmitGPRel32Value(const MCExpr *Value) {
   EmitEOL();
 }
 
 /// EmitFill - Emit NumBytes bytes worth of the value specified by
 /// FillValue.  This implements directives such as '.space'.
 void MCAsmStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue) {
   if (NumBytes == 0) return;
 
+  const MCExpr *E = MCConstantExpr::create(NumBytes, getContext());
+  emitFill(*E, FillValue);
+}
+
+void MCAsmStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
+                             SMLoc Loc) {
   if (const char *ZeroDirective = MAI->getZeroDirective()) {
-    OS << ZeroDirective << NumBytes;
+    // FIXME: Emit location directives
+    OS << ZeroDirective;
+    NumBytes.print(OS, MAI);
     if (FillValue != 0)
       OS << ',' << (int)FillValue;
     EmitEOL();
     return;
   }
 
-  // Emit a byte at a time.
-  MCStreamer::EmitFill(NumBytes, FillValue);
+  MCStreamer::emitFill(NumBytes, FillValue);
+}
+
+void MCAsmStreamer::emitFill(uint64_t NumValues, int64_t Size, int64_t Expr) {
+  if (NumValues == 0)
+    return;
+
+  const MCExpr *E = MCConstantExpr::create(NumValues, getContext());
+  emitFill(*E, Size, Expr);
+}
+
+void MCAsmStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
+                             int64_t Expr, SMLoc Loc) {
+  // FIXME: Emit location directives
+  OS << "\t.fill\t";
+  NumValues.print(OS, MAI);
+  OS << ", " << Size << ", 0x";
+  OS.write_hex(truncateToSize(Expr, 32));
+  EmitEOL();
 }
 
 void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
                                          unsigned ValueSize,
                                          unsigned MaxBytesToEmit) {
   // Some assemblers don't support non-power of two alignments, so we always
   // emit alignments as a power of two if possible.
   if (isPowerOf2_32(ByteAlignment)) {

llvm/trunk/lib/MC/MCObjectStreamer.cpp

 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 using namespace llvm;
 
 MCObjectStreamer::MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB,
                                    raw_pwrite_stream &OS,
                                    MCCodeEmitter *Emitter_)
     : MCStreamer(Context),
       Assembler(new MCAssembler(Context, TAB, *Emitter_,

 
 void MCObjectStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue) {
   const MCSection *Sec = getCurrentSection().first;
   (void)Sec;
   assert(Sec && "need a section");
   insert(new MCFillFragment(FillValue, NumBytes));
 }
 
+void MCObjectStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
+                                SMLoc Loc) {
+  MCDataFragment *DF = getOrCreateDataFragment();
+  flushPendingLabels(DF, DF->getContents().size());
+
+  int64_t IntNumBytes;
+  if (!NumBytes.evaluateAsAbsolute(IntNumBytes, getAssembler())) {
+    getContext().reportError(Loc, "expected absolute expression");
+    return;
+  }
+
+  if (IntNumBytes <= 0) {
+    getContext().reportError(Loc, "invalid number of bytes");
+    return;
+  }
+
+  EmitFill(IntNumBytes, FillValue);
+}
+
+void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
+                                int64_t Expr, SMLoc Loc) {
+  int64_t IntNumValues;
+  if (!NumValues.evaluateAsAbsolute(IntNumValues, getAssembler())) {
+    getContext().reportError(Loc, "expected absolute expression");
+    return;
+  }
+
+  if (IntNumValues < 0) {
+    getContext().getSourceManager()->PrintMessage(
+        Loc, SourceMgr::DK_Warning,
+        "'.fill' directive with negative repeat count has no effect");
+    return;
+  }
+
+  MCStreamer::emitFill(IntNumValues, Size, Expr);
+}
+
 void MCObjectStreamer::FinishImpl() {
   // If we are generating dwarf for assembly source files dump out the sections.
   if (getContext().getGenDwarfForAssembly())
     MCGenDwarfInfo::Emit(this);
 
   // Dump out the dwarf file & directory tables and line tables.
   MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
 
   flushPendingLabels(nullptr);
   getAssembler().Finish();
 }

llvm/trunk/lib/MC/MCParser/AsmParser.cpp

bool AsmParser::parseDirectiveRealValue(const fltSemantics &Semantics) {
   return false;
 }
 
 /// parseDirectiveZero
 ///  ::= .zero expression
 bool AsmParser::parseDirectiveZero() {
   checkForValidSection();
 
-  int64_t NumBytes;
-  if (parseAbsoluteExpression(NumBytes))
+  SMLoc NumBytesLoc = Lexer.getLoc();
+  const MCExpr *NumBytes;
+  if (parseExpression(NumBytes))
     return true;
 
   int64_t Val = 0;
   if (getLexer().is(AsmToken::Comma)) {
     Lex();
     if (parseAbsoluteExpression(Val))
       return true;
   }
 
   if (getLexer().isNot(AsmToken::EndOfStatement))
     return TokError("unexpected token in '.zero' directive");
 
   Lex();
 
-  getStreamer().EmitFill(NumBytes, Val);
+  getStreamer().emitFill(*NumBytes, Val, NumBytesLoc);
 
   return false;
 }
 
 /// parseDirectiveFill
 ///  ::= .fill expression [ , expression [ , expression ] ]
 bool AsmParser::parseDirectiveFill() {
   checkForValidSection();
 
-  SMLoc RepeatLoc = getLexer().getLoc();
-  int64_t NumValues;
-  if (parseAbsoluteExpression(NumValues))
+  SMLoc NumValuesLoc = Lexer.getLoc();
+  const MCExpr *NumValues;
+  if (parseExpression(NumValues))
     return true;
 
-  if (NumValues < 0) {
-    Warning(RepeatLoc,
-            "'.fill' directive with negative repeat count has no effect");
-    NumValues = 0;
-  }
-
   int64_t FillSize = 1;
   int64_t FillExpr = 0;
 
   SMLoc SizeLoc, ExprLoc;
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     if (getLexer().isNot(AsmToken::Comma))
       return TokError("unexpected token in '.fill' directive");
     Lex();
if (getLexer().isNot(AsmToken::EndOfStatement)) {
         return TokError("unexpected token in '.fill' directive");
 
       Lex();
     }
   }
 
   if (FillSize < 0) {
     Warning(SizeLoc, "'.fill' directive with negative size has no effect");
-    NumValues = 0;
+    NumValues = MCConstantExpr::create(0, getStreamer().getContext());
   }
   if (FillSize > 8) {
     Warning(SizeLoc, "'.fill' directive with size greater than 8 has been truncated to 8");
     FillSize = 8;
   }
 
   if (!isUInt<32>(FillExpr) && FillSize > 4)
     Warning(ExprLoc, "'.fill' directive pattern has been truncated to 32-bits");
 
-  if (NumValues > 0) {
-    int64_t NonZeroFillSize = FillSize > 4 ? 4 : FillSize;
-    FillExpr &= ~0ULL >> (64 - NonZeroFillSize * 8);
-    for (uint64_t i = 0, e = NumValues; i != e; ++i) {
-      getStreamer().EmitIntValue(FillExpr, NonZeroFillSize);
-      if (NonZeroFillSize < FillSize)
-        getStreamer().EmitIntValue(0, FillSize - NonZeroFillSize);
-    }
-  }
+  getStreamer().emitFill(*NumValues, FillSize, FillExpr, NumValuesLoc);
 
   return false;
 }
 
 /// parseDirectiveOrg
 ///  ::= .org expression [ , expression ]
 bool AsmParser::parseDirectiveOrg() {
   checkForValidSection();
bool AsmParser::parseDirectiveBundleUnlock() {
   return false;
 }
 
 /// parseDirectiveSpace
 /// ::= (.skip | .space) expression [ , expression ]
 bool AsmParser::parseDirectiveSpace(StringRef IDVal) {
   checkForValidSection();
 
-  int64_t NumBytes;
-  if (parseAbsoluteExpression(NumBytes))
+  SMLoc NumBytesLoc = Lexer.getLoc();
+  const MCExpr *NumBytes;
+  if (parseExpression(NumBytes))
     return true;
 
   int64_t FillExpr = 0;
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     if (getLexer().isNot(AsmToken::Comma))
       return TokError("unexpected token in '" + Twine(IDVal) + "' directive");
     Lex();
 
     if (parseAbsoluteExpression(FillExpr))
       return true;
 
     if (getLexer().isNot(AsmToken::EndOfStatement))
       return TokError("unexpected token in '" + Twine(IDVal) + "' directive");
   }
 
   Lex();
 
-  if (NumBytes <= 0)
-    return TokError("invalid number of bytes in '" + Twine(IDVal) +
-                    "' directive");
-
   // FIXME: Sometimes the fill expr is 'nop' if it isn't supplied, instead of 0.
-  getStreamer().EmitFill(NumBytes, FillExpr);
+  getStreamer().emitFill(*NumBytes, FillExpr, NumBytesLoc);
 
   return false;
 }
 
 /// parseDirectiveLEB128
 /// ::= (.sleb128 | .uleb128) [ expression (, expression)* ]
 bool AsmParser::parseDirectiveLEB128(bool Signed) {
   checkForValidSection();

llvm/trunk/lib/MC/MCStreamer.cpp

 
 void MCStreamer::EmitGPRel32Value(const MCExpr *Value) {
   report_fatal_error("unsupported directive in streamer");
 }
 
 /// EmitFill - Emit NumBytes bytes worth of the value specified by
 /// FillValue.  This implements directives such as '.space'.
 void MCStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue) {
-  const MCExpr *E = MCConstantExpr::create(FillValue, getContext());
   for (uint64_t i = 0, e = NumBytes; i != e; ++i)
-    EmitValue(E, 1);
+    EmitIntValue(FillValue, 1);
+}
+
+void MCStreamer::emitFill(uint64_t NumValues, int64_t Size, int64_t Expr) {
+  int64_t NonZeroSize = Size > 4 ? 4 : Size;
+  Expr &= ~0ULL >> (64 - NonZeroSize * 8);
+  for (uint64_t i = 0, e = NumValues; i != e; ++i) {
+    EmitIntValue(Expr, NonZeroSize);
+    if (NonZeroSize < Size)
+      EmitIntValue(0, Size - NonZeroSize);
+  }
 }
 
 /// The implementation in this class just redirects to EmitFill.
 void MCStreamer::EmitZeros(uint64_t NumBytes) {
   EmitFill(NumBytes, 0);
 }
 
 unsigned MCStreamer::EmitDwarfFileDirective(unsigned FileNo,

 void MCStreamer::ChangeSection(MCSection *, const MCExpr *) {}
 void MCStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {}
 void MCStreamer::EmitBytes(StringRef Data) {}
 void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) {
   visitUsedExpr(*Value);
 }
 void MCStreamer::EmitULEB128Value(const MCExpr *Value) {}
 void MCStreamer::EmitSLEB128Value(const MCExpr *Value) {}
+void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {}
+void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
+                          SMLoc Loc) {}
 void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
                                       unsigned ValueSize,
                                       unsigned MaxBytesToEmit) {}
 void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment,
                                    unsigned MaxBytesToEmit) {}
 void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value) {}
 void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
 void MCStreamer::EmitBundleLock(bool AlignToEnd) {}

llvm/trunk/test/MC/AsmParser/directive_fill.s

 # RUN: llvm-mc -triple i386-unknown-unknown %s 2> %t.err | FileCheck %s
 # RUN: FileCheck --check-prefix=CHECK-WARNINGS %s < %t.err
 
 # CHECK: TEST0:
-# CHECK: .byte 10
+# CHECK: .fill 1, 1, 0xa
 TEST0:  
         .fill 1, 1, 10
 
 # CHECK: TEST1:
-# CHECK: .short 3
-# CHECK: .short 3
+# CHECK: .fill 2, 2, 0x3
 TEST1:  
         .fill 2, 2, 3
 
 # CHECK: TEST2:
-# CHECK: .long 4
-# CHECK: .long 0
+# CHECK: .fill 1, 8, 0x4
 TEST2:  
         .fill 1, 8, 4
 
 # CHECK: TEST3
-# CHECK: .byte 0
-# CHECK: .byte 0
-# CHECK: .byte 0
-# CHECK: .byte 0
+# CHECK: .fill 4
 TEST3:
   .fill 4
 
 # CHECK: TEST4
-# CHECK: .short 0
-# CHECK: .short 0
-# CHECK: .short 0
-# CHECK: .short 0
+# CHECK: .fill 4, 2
 TEST4:
   .fill 4, 2
 
 # CHECK: TEST5
-# CHECK: .short  2
-# CHECK: .byte   0
-# CHECK: .short  2
-# CHECK: .byte   0
-# CHECK: .short  2
-# CHECK: .byte   0
-# CHECK: .short  2
-# CHECK: .byte   0
+# CHECK: .fill 4, 3, 0x2
 TEST5:
   .fill 4, 3, 2
 
 # CHECK: TEST6
-# CHECK: .long 2
-# CHECK: .long 0
+# CHECK: .fill 1, 8, 0x2
 # CHECK-WARNINGS: '.fill' directive with size greater than 8 has been truncated to 8
 TEST6:
   .fill 1, 9, 2
 
 # CHECK: TEST7
-# CHECK: .long 0
-# CHECK: .long 0
+# CHECK: .fill 1, 8, 0x100000000
 # CHECK-WARNINGS: '.fill' directive pattern has been truncated to 32-bits
 TEST7:
   .fill 1, 8, 1<<32
 
 # CHECK-WARNINGS: '.fill' directive with negative repeat count has no effect
 TEST8:
   .fill -1, 8, 1
 
 # CHECK-WARNINGS: '.fill' directive with negative size has no effect
 TEST9:
   .fill 1, -1, 1
 
 # CHECK: TEST10
-# CHECK: .short  22136
-# CHECK: .byte   52
+# CHECK: .fill 1, 3, 0x12345678
 TEST10:
   .fill 1, 3, 0x12345678
+
+# CHECK: .fill TEST11-TEST10, 1, 0x0
+TEST11:
+  .fill TEST11 - TEST10
+
+# CHECK: .fill TEST11-TEST12, 3, 0x12345678
+TEST12:
+  .fill TEST11 - TEST12, 3, 0x12345678

llvm/trunk/test/MC/AsmParser/directive_space.s

 # RUN: llvm-mc -triple i386-apple-darwin %s | FileCheck %s
 
 # CHECK: TEST0:
 # CHECK: .space 1
 TEST0:  
         .space 1
 
 # CHECK: TEST1:
 # CHECK: .space 2,3
 TEST1:  
         .space 2, 3
 
 # CHECK: TEST2:
 # CHECK: .space 1
 TEST2:
         .skip 1
+
+# CHECK: TEST3
+# CHECK: .space TEST0-TEST1
+TEST3:
+        .space TEST0 - TEST1

llvm/trunk/test/MC/AsmParser/symbolic-expression.s

+# RUN: llvm-mc -filetype=obj -triple=i386-unknown-elf %s | llvm-objdump -t - | FileCheck %s
+
+# CHECK: 00000000         .text           00000000 TEST0
+TEST0:
+  .fill 0x10
+# CHECK: 00000010         .text           00000000 TEST1
+TEST1:
+  .fill TEST1 - TEST0 + 0x5
+# CHECK: 00000025         .text           00000000 TEST2
+TEST2:
+  .zero TEST2 - (TEST1 + 0x5)
+# CHECK: 00000035         .text           00000000 TEST3
+TEST3:
+  .skip (TEST1 - TEST0) * 2
+# CHECK: 00000055         .text           00000000 TEST4
+TEST4:
+  .space TEST2 - TEST1, 1