[ELF] - Show data and assignment commands in the map file.

[grimar]

Summary

With given script:

SECTIONS {
  . = 0x1000;
  .foo : {
    BYTE(0x11)
    SHORT(0x1122)
    LONG(0x11223344)
    QUAD(0x1122334455667788)
    *(.foo.1)
    . += 0x1000;
  }
}

BFD shows data commands and location counter moving in the map file:

.foo          0x0000000000001000      0x117
                0x0000000000001000        0x1 BYTE 0x11
                0x0000000000001001        0x2 SHORT 0x1122
                0x0000000000001003        0x4 LONG 0x11223344
                0x0000000000001007        0x8 QUAD 0x1122334455667788
 *(.foo.1)
 .foo.1         0x000000000000100f        0x8 map-file.test.tmp.o
                0x0000000000001117                . = (. + 0x100)
 *fill*         0x0000000000001017      0x100

Patch teaches LLD to do the same.

[ruiu]

GNU linker's output (for example . = (. + 0x100)) looks useful but I don't think showing only data command is not that useful given that the usage is low. Also, that's not a difficult or interesting part of debugging linker scripts. So I don't think we don't want this unless you have a plan to extend it to show all linker scripts commands.

[grimar]

In D44004#1025788, @ruiu wrote:

GNU linker's output (for example . = (. + 0x100)) looks useful but I don't think showing only data command is not that useful given that the usage is low. Also, that's not a difficult or interesting part of debugging linker scripts. So I don't think we don't want this unless you have a plan to extend it to show all linker scripts commands.

Yes, my intention was to support . = (. + 0x100) and this one was a first step. I'll extend the patch and update then.

[grimar]

• Added support for assignment commands.

[ruiu]

ELF/LinkerScript.h

113

StringView isn't a good name because we have std::string_view in modern C++.

115–116

They need a comment.

ELF/ScriptParser.cpp

794

Tok means a token, and position is not a token, so this name is confusing.

795–798

You can use llvm::join, can't you?

[grimar]

• Addressed review comments.

[ruiu]

ELF/LinkerScript.h

112–113

It is obvious that this comment describe the following variable, so you don't need to mention that.

// A string representation of this command. We use this for -Map.

115

Please insert a blank line before a comment.

115

What do you mean by "before execution of assignment"? Before you assign a command to an output section, it doesn't have any address.

ELF/MapFile.cpp

210

You are passing Cmd->Size as an alignment which seems wrong to me.

ELF/ScriptParser.cpp

118–119

FirstTok and LastTok are not tokens but positions, so you should avoid "Tok".

796

This looks weird -- at least I believe you could do Prefix.str() + " " + ....

804–805

You should change the ctor so that it takes CommandString as the third parameter. Half-initializing an object using the constructor and then set a new value to a member looks weird.

[• rafael]

George Rimar via Phabricator via llvm-commits
<[e-mail]> writes:

+# RUN: ld.lld -o %t %t.o -Map=%t.map --script %s
+# RUN: FileCheck -strict-whitespace %s < %t.map

Why do you need -strict-whitespace? The fact that you have a newline in
0x123 * (1+1) should be sufficient, no?

+ // Keeps string representing the expression. Used when printing map file.
+ StringRef StringView;
+
+ unsigned Offset;
+ unsigned Size;

Add a comment about Offset and Size. Looking at a SymbolAssignment one
could assume Offset is the offset in a section and Size the size of the
elf symbol.

Cheers,
Rafael

[• rafael]

LGTM

George Rimar via Phabricator via llvm-commits
<[e-mail]> writes:

grimar updated this revision to Diff 137382.
grimar marked 4 inline comments as done.
grimar added a comment.

• Addressed review comments.

https://reviews.llvm.org/D44004

Files:

ELF/LinkerScript.cpp
ELF/LinkerScript.h
ELF/MapFile.cpp
ELF/ScriptParser.cpp
test/ELF/linkerscript/map-file.test

Index: test/ELF/linkerscript/map-file.test

• test/ELF/linkerscript/map-file.test

+++ test/ELF/linkerscript/map-file.test
@@ -0,0 +1,38 @@
+# REQUIRES: x86
+
+# RUN: echo ".section .foo.1,\"a\"" > %t.s
+# RUN: echo ".quad 1" >> %t.s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.s -o %t.o
+
+# RUN: ld.lld -o %t %t.o -Map=%t.map --script %s
+# RUN: FileCheck -strict-whitespace %s < %t.map
+
+SECTIONS {
+ . = 0x1000;
+ .foo : {
+ BYTE(0x11)
+ SHORT(0x1122)
+ LONG(0x11223344)
+ QUAD(0x1122334455667788)
+ . += 0x1000;
+ *(.foo.1)
+ . += 0x123 *
+ (1 + 1);
+ foo = .;
+ bar = 0x42 - 0x26;
+ }
+}
+
+# CHECK: Address Size Align Out In Symbol
+# CHECK-NEXT: 0000000000001000 000000000000125d 1 .foo
+# CHECK-NEXT: 0000000000001000 0000000000000001 1 BYTE ( 0x11 )
+# CHECK-NEXT: 0000000000001001 0000000000000002 2 SHORT ( 0x1122 )
+# CHECK-NEXT: 0000000000001003 0000000000000004 4 LONG ( 0x11223344 )
+# CHECK-NEXT: 0000000000001007 0000000000000008 8 QUAD ( 0x1122334455667788 )
+# CHECK-NEXT: 000000000000100f 0000000000001000 1 . += 0x1000
+# CHECK-NEXT: 000000000000200f 0000000000000008 1 {{.*}}{{/|\\}}map-file.test.tmp.o:(.foo.1)
+# CHECK-NEXT: 0000000000002017 0000000000000246 1 . += 0x123 * ( 1 + 1 )
+# CHECK-NEXT: 000000000000225d 0000000000000000 1 foo = .
+# CHECK-NEXT: 000000000000225d 0000000000000000 1 bar = 0x42 - 0x26
+# CHECK-NEXT: 0000000000002260 0000000000000000 4 .text
+# CHECK-NEXT: 0000000000002260 0000000000000000 4 {{.*}}{{/|\\}}map-file.test.tmp.o:(.text)

Index: ELF/ScriptParser.cpp

• ELF/ScriptParser.cpp

+++ ELF/ScriptParser.cpp
@@ -114,6 +114,10 @@

std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
readSymbols();

+ // Concatenates tokens in a [FirstTok, LastTok] into string with Prefix.
+ std::string buildCommandString(StringRef Prefix, size_t FirstTok,
+ size_t LastTok);
+

// True if a script being read is in a subdirectory specified by -sysroot.
bool IsUnderSysroot;

@@ -773,15 +777,25 @@

return Cmd;

}

+std::string ScriptParser::buildCommandString(StringRef Prefix, size_t FirstTok,
+ size_t LastTok) {
+ return (Prefix + " ").str() +
+ llvm::join(Tokens.begin() + FirstTok, Tokens.begin() + LastTok, " ");
+}
+
SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
+ size_t OldPos = Pos;

StringRef Op = next();
assert(Op == "=" || Op == "+=");
Expr E = readExpr();
if (Op == "+=") {
  std::string Loc = getCurrentLocation();
  E = [=] { return add(Script->getSymbolValue(Name, Loc), E()); };
}

• return make<SymbolAssignment>(Name, E, getCurrentLocation());

+
+ SymbolAssignment *Ret = make<SymbolAssignment>(Name, E, getCurrentLocation());
+ Ret->CommandString = buildCommandString(Name, OldPos, Pos);
+ return Ret;
}

// This is an operator-precedence parser to parse a linker
@@ -935,7 +949,11 @@

               .Default(-1);
if (Size == -1)
  return nullptr;

• return make<ByteCommand>(readParenExpr(), Size);

+
+ size_t OldPos = Pos;
+ ByteCommand *Ret = make<ByteCommand>(readParenExpr(), Size);
+ Ret->CommandString = buildCommandString(Tok, OldPos, Pos);
+ return Ret;
}

StringRef ScriptParser::readParenLiteral() {

Index: ELF/MapFile.cpp

• ELF/MapFile.cpp

+++ ELF/MapFile.cpp
@@ -138,11 +138,29 @@

OS << OSec->Name << '\n';
 
// Dump symbols for each input section.

• for (InputSection *IS : getInputSections(OSec)) {
• writeHeader(OS, OSec->Addr + IS->OutSecOff, IS->getSize(), IS->Alignment);
• OS << Indent1 << toString(IS) << '\n';
• for (Symbol *Sym : SectionSyms[IS])
• OS << SymStr[Sym] << '\n';

+ for (BaseCommand *Base : OSec->SectionCommands) {
+ if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
+ for (InputSection *IS : ISD->Sections) {
+ writeHeader(OS, OSec->Addr + IS->OutSecOff, IS->getSize(),
+ IS->Alignment);
+ OS << Indent1 << toString(IS) << '\n';
+ for (Symbol *Sym : SectionSyms[IS])
+ OS << SymStr[Sym] << '\n';
+ }
+ continue;
+ }
+
+ if (auto *Cmd = dyn_cast<ByteCommand>(Base)) {
+ writeHeader(OS, OSec->Addr + Cmd->Offset, Cmd->Size, Cmd->Size);
+ OS << Indent1 << Cmd->CommandString << '\n';
+ continue;
+ }
+
+ if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
+ writeHeader(OS, OSec->Addr + Cmd->Offset, Cmd->Size, 1);
+ OS << Indent1 << Cmd->CommandString << '\n';
+ continue;
+ }

  }
}

}

Index: ELF/LinkerScript.h

• ELF/LinkerScript.h

+++ ELF/LinkerScript.h
@@ -106,6 +106,14 @@

// Holds file name and line number for error reporting.
std::string Location;

+
+ Following attributes are used for printing the map file.
+ Keeps string representing the command.
+ std::string CommandString;
+ The offset value within the section before execution of assignment.
+ unsigned Offset;
+ The value by which the assignment changed the output section size.
+ unsigned Size;
};

// Linker scripts allow additional constraints to be put on ouput sections.
@@ -183,6 +191,9 @@

static bool classof(const BaseCommand *C) { return C->Kind == ByteKind; }

+ // Keeps string representing the command. Used when printing map file.
+ std::string CommandString;
+

Expr Expression;
unsigned Offset;
unsigned Size;

Index: ELF/LinkerScript.cpp

• ELF/LinkerScript.cpp

+++ ELF/LinkerScript.cpp
@@ -739,7 +739,9 @@

for (BaseCommand *Base : Sec->SectionCommands) {
  // This handles the assignments to symbol or to the dot.
  if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {

+ Cmd->Offset = Dot - Ctx->OutSec->Addr;

assignSymbol(Cmd, true);

+ Cmd->Size = Dot - Ctx->OutSec->Addr - Cmd->Offset;

  continue;
}

---

llvm-commits mailing list
[e-mail]
http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits

[grimar]

• Addressed review comments.

ELF/LinkerScript.h

115

I mean that if we have a section description:

0  .foo : {
1    *(.bar)
2    . += 0x123;
3  }

Then at line 2, we have an assignment to Dot.
We handle commands one by one and offset before we process
("before execution of assignment (command)" in my wording) the assignment will
be equal to the size of .bar. That offset is saved to Offset member.
After execution of assignment command, offset will be different and Size below
stores the difference.

I rewrote the comment slightly.

ELF/MapFile.cpp

210

Right, that was incorrect, changed to 1.

ELF/ScriptParser.cpp

118–119

Not sure what is wrong here honestly.
I think first and last can be both adjectives and nouns. I meant that they are adjectives describing the
tokens and hence they are not positions here I think.
I renamed to First/Last though as such naming is also OK for me.

[• rafael]

George Rimar via Phabricator <[e-mail]> writes:

grimar added inline comments.

Comment at: ELF/LinkerScript.h:113
+ std::string CommandString;
+ // The offset value within the section before execution of assignment.

+ unsigned Offset;

ruiu wrote:

ruiu wrote:

Please insert a blank line before a comment.

What do you mean by "before execution of assignment"? Before you assign a command to an output section, it doesn't have any address.

I mean that if we have a section description:

0  .foo : {
1    *(.bar)
2    . += 0x123;
3  }

Then at line 2, we have an assignment to Dot.
We handle commands one by one and offset before we process
("before execution of assignment (command)" in my wording) the assignment will
be equal to the size of .bar. That offset is saved to Offset member.
After execution of assignment command, offset will be different and Size below
stores the difference.

I rewrote the comment slightly.

Comment at: ELF/MapFile.cpp:154
+ if (auto *Cmd = dyn_cast<ByteCommand>(Base)) {
+ writeHeader(OS, OSec->Addr + Cmd->Offset, Cmd->Size, Cmd->Size);

+ OS << Indent1 << Cmd->CommandString << '\n';

ruiu wrote:

You are passing Cmd->Size as an alignment which seems wrong to me.

Right, that was incorrect, changed to 1.

Comment at: ELF/ScriptParser.cpp:118-119
+ // Concatenates tokens in a [FirstTok, LastTok] into string with Prefix.
+ std::string buildCommandString(StringRef Prefix, size_t FirstTok,
+ size_t LastTok);

+

ruiu wrote:

FirstTok and LastTok are not tokens but positions, so you should avoid "Tok".

Not sure what is wrong here honestly.
I think first and last can be both adjectives and nouns. I meant that they are adjectives describing the
tokens and hence they are not positions here I think.
I renamed to First/Last though as such naming is also OK for me.

I think Rui's objection is that one would expect a *Tok variable to be
a StringRef. What you have are token number/indexes. I am ok with
First/Last, but maybe FirstTokI/LastTokI would be best.

Cheers,
Rafael

[grimar]

In D44004#1031551, @rafael wrote:

ruiu wrote:

FirstTok and LastTok are not tokens but positions, so you should avoid "Tok".

Not sure what is wrong here honestly.
I think first and last can be both adjectives and nouns. I meant that they are adjectives describing the
tokens and hence they are not positions here I think.
I renamed to First/Last though as such naming is also OK for me.

I think Rui's objection is that one would expect a *Tok variable to be
a StringRef. What you have are token number/indexes. I am ok with
First/Last, but maybe FirstTokI/LastTokI would be best.

Cheers,
Rafael

Ah, thanks, now I see my mistake, I misunderstood initial objection.
Both ways of new namings look OK to me I think.

[grimar]

Ping.

[• rafael]

George Rimar via Phabricator <[e-mail]> writes:

+ // Concatenates tokens in a [First, Last] into string with Prefix.
+ std::string buildCommandString(StringRef Prefix, size_t First, size_t Last);

It is [First, Last), no?

LGTM with that.

Cheers,
Rafael

[ruiu]

LGTM with these changes.

ELF/LinkerScript.h

115

Just "This is just an offset of this assignment command in the output section" should be more clear. "before processing the assignment" doesn't make much sense to me.

118

"Size of this assignment command. This is usually 0, but if you move '.' or use a BYTE()-family command, this may be greater than 0."

199

"Used for -Map" is perhaps better.

ELF/ScriptParser.cpp

794

I think it doesn't have to be a function; actually I believe it is easier to read if you inline it.

ELF/LinkerScript.h

 
 struct BaseCommand {
   BaseCommand(int K) : Kind(K) {}
   int Kind;
 };
 
 // This represents ". = <expr>" or "<symbol> = <expr>".
 struct SymbolAssignment : BaseCommand {
-  SymbolAssignment(StringRef Name, Expr E, std::string Loc)
-      : BaseCommand(AssignmentKind), Name(Name), Expression(E), Location(Loc) {}
+  SymbolAssignment(StringRef Name, Expr E, std::string Loc,
+                   std::string CommandString)
+      : BaseCommand(AssignmentKind), Name(Name), Expression(E), Location(Loc),
+        CommandString(CommandString) {}
 
   static bool classof(const BaseCommand *C) {
     return C->Kind == AssignmentKind;
   }
 
   // The LHS of an expression. Name is either a symbol name or ".".
   StringRef Name;
   Defined *Sym = nullptr;
 
   // The RHS of an expression.
   Expr Expression;
 
   // Command attributes for PROVIDE, HIDDEN and PROVIDE_HIDDEN.
   bool Provide = false;
   bool Hidden = false;
 
   // Holds file name and line number for error reporting.
   std::string Location;
+
+  // A string representation of this command. We use this for -Map.
+  std::string CommandString;
+
+  // This is just an offset of this assignment command in the output section.
+  unsigned Offset;
+
+  // Size of this assignment command. This is usually 0, but if you move '.'
+  // or use a BYTE()-family command, this may be greater than 0."
+  unsigned Size;
 };
 
 // Linker scripts allow additional constraints to be put on ouput sections.
 // If an output section is marked as ONLY_IF_RO, the section is created
 // only if its input sections are read-only. Likewise, an output section
 // with ONLY_IF_RW is created if all input sections are RW.
 enum class ConstraintKind { NoConstraint, ReadOnly, ReadWrite };
 
struct AssertCommand : BaseCommand {
 
   static bool classof(const BaseCommand *C) { return C->Kind == AssertKind; }
 
   Expr Expression;
 };
 
 // Represents BYTE(), SHORT(), LONG(), or QUAD().
 struct ByteCommand : BaseCommand {
-  ByteCommand(Expr E, unsigned Size)
-      : BaseCommand(ByteKind), Expression(E), Size(Size) {}
+  ByteCommand(Expr E, unsigned Size, std::string CommandString)
+      : BaseCommand(ByteKind), Expression(E), Size(Size),
+        CommandString(CommandString) {}
 
   static bool classof(const BaseCommand *C) { return C->Kind == ByteKind; }
 
+  // Keeps string representing the command. Used for -Map" is perhaps better.
+  std::string CommandString;
+
   Expr Expression;
   unsigned Offset;
   unsigned Size;
 };
 
 struct PhdrsCommand {
   StringRef Name;
   unsigned Type = llvm::ELF::PT_NULL;

ELF/LinkerScript.cpp

void LinkerScript::assignOffsets(OutputSection *Sec) {
   Sec->Size = 0;
 
   // We visited SectionsCommands from processSectionCommands to
   // layout sections. Now, we visit SectionsCommands again to fix
   // section offsets.
   for (BaseCommand *Base : Sec->SectionCommands) {
     // This handles the assignments to symbol or to the dot.
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
+      Cmd->Offset = Dot - Ctx->OutSec->Addr;
       assignSymbol(Cmd, true);
+      Cmd->Size = Dot - Ctx->OutSec->Addr - Cmd->Offset;
       continue;
     }
 
     // Handle BYTE(), SHORT(), LONG(), or QUAD().
     if (auto *Cmd = dyn_cast<ByteCommand>(Base)) {
       Cmd->Offset = Dot - Ctx->OutSec->Addr;
       Dot += Cmd->Size;
       expandOutputSection(Cmd->Size);

ELF/MapFile.cpp

OS << left_justify("Address", W) << ' ' << left_justify("Size", W)
      << " Align Out     In      Symbol\n";
 
   // Print out file contents.
   for (OutputSection *OSec : OutputSections) {
     writeHeader(OS, OSec->Addr, OSec->Size, OSec->Alignment);
     OS << OSec->Name << '\n';
 
     // Dump symbols for each input section.
-    for (InputSection *IS : getInputSections(OSec)) {
+    for (BaseCommand *Base : OSec->SectionCommands) {
+      if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
+        for (InputSection *IS : ISD->Sections) {
           if (IS == InX::EhFrame) {
             printEhFrame(OS, OSec);
             continue;
           }
 
-      writeHeader(OS, OSec->Addr + IS->OutSecOff, IS->getSize(), IS->Alignment);
+          writeHeader(OS, OSec->Addr + IS->OutSecOff, IS->getSize(),
+                      IS->Alignment);
           OS << Indent8 << toString(IS) << '\n';
           for (Symbol *Sym : SectionSyms[IS])
             OS << SymStr[Sym] << '\n';
         }
+        continue;
+      }
+
+      if (auto *Cmd = dyn_cast<ByteCommand>(Base)) {
+        writeHeader(OS, OSec->Addr + Cmd->Offset, Cmd->Size, 1);
+        OS << Indent8 << Cmd->CommandString << '\n';
+        continue;
+      }
+
+      if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
+        writeHeader(OS, OSec->Addr + Cmd->Offset, Cmd->Size, 1);
+        OS << Indent8 << Cmd->CommandString << '\n';
+        continue;
+      }
+    }
   }
 }
 
 static void print(StringRef A, StringRef B) {
   outs() << left_justify(A, 49) << " " << B << "\n";
 }
 
 // Output a cross reference table to stdout. This is for --cref.
 //
 // For each global symbol, we print out a file that defines the symbol

ELF/ScriptParser.cpp

private:
   std::vector<SymbolVersion> readVersionExtern();
   void readAnonymousDeclaration();
   void readVersionDeclaration(StringRef VerStr);
 
   std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
   readSymbols();
 
   // True if a script being read is in a subdirectory specified by -sysroot.
   bool IsUnderSysroot;
 
   // A set to detect an INCLUDE() cycle.
   StringSet<> Seen;
 };
 } // namespace
 
 static StringRef unquote(StringRef S) {
   if (S.startswith("\""))
     return S.substr(1, S.size() - 2);
while (!atEOF()) {
     }
   }
 }
 
 void ScriptParser::readDefsym(StringRef Name) {
   Expr E = readExpr();
   if (!atEOF())
     setError("EOF expected, but got " + next());
-  SymbolAssignment *Cmd = make<SymbolAssignment>(Name, E, getCurrentLocation());
+  SymbolAssignment *Cmd = make<SymbolAssignment>(Name, E, getCurrentLocation(),
+                                                 "" /*CommandString*/);
   Script->SectionCommands.push_back(Cmd);
 }
 
 void ScriptParser::addFile(StringRef S) {
   if (IsUnderSysroot && S.startswith("/")) {
     SmallString<128> PathData;
     StringRef Path = (Config->Sysroot + S).toStringRef(PathData);
     if (sys::fs::exists(Path)) {
SymbolAssignment *ScriptParser::readProvideOrAssignment(StringRef Tok) {
   } else if (Tok == "HIDDEN") {
     Cmd = readProvideHidden(false, true);
   } else if (Tok == "PROVIDE_HIDDEN") {
     Cmd = readProvideHidden(true, true);
   }
   return Cmd;
 }
 
 SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
+  size_t OldPos = Pos;
   StringRef Op = next();
   assert(Op == "=" || Op == "+=");
   Expr E = readExpr();
   if (Op == "+=") {
     std::string Loc = getCurrentLocation();
     E = [=] { return add(Script->getSymbolValue(Name, Loc), E()); };
   }
-  return make<SymbolAssignment>(Name, E, getCurrentLocation());
+
+  std::string CommandString =
+      Name.str() + " " +
+      llvm::join(Tokens.begin() + OldPos, Tokens.begin() + Pos, " ");
+  return make<SymbolAssignment>(Name, E, getCurrentLocation(), CommandString);
 }
 
 // This is an operator-precedence parser to parse a linker
 // script expression.
 Expr ScriptParser::readExpr() {
   // Our lexer is context-aware. Set the in-expression bit so that
   // they apply different tokenization rules.
   bool Orig = InExpr;
ByteCommand *ScriptParser::readByteCommand(StringRef Tok) {
   int Size = StringSwitch<int>(Tok)
                  .Case("BYTE", 1)
                  .Case("SHORT", 2)
                  .Case("LONG", 4)
                  .Case("QUAD", 8)
                  .Default(-1);
   if (Size == -1)
     return nullptr;
-  return make<ByteCommand>(readParenExpr(), Size);
+
+  size_t OldPos = Pos;
+  Expr E = readParenExpr();
+  std::string CommandString =
+      Tok.str() + " " +
+      llvm::join(Tokens.begin() + OldPos, Tokens.begin() + Pos, " ");
+  return make<ByteCommand>(E, Size, CommandString);
 }
 
 StringRef ScriptParser::readParenLiteral() {
   expect("(");
   bool Orig = InExpr;
   InExpr = false;
   StringRef Tok = next();
   InExpr = Orig;

test/ELF/linkerscript/map-file.test

+# REQUIRES: x86
+
+# RUN: echo ".section .foo.1,\"a\"" > %t.s
+# RUN: echo ".quad 1" >> %t.s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.s -o %t.o
+
+# RUN: ld.lld -o %t %t.o -Map=%t.map --script %s
+# RUN: FileCheck -strict-whitespace %s < %t.map
+
+SECTIONS {
+  . = 0x1000;
+  .foo : {
+    BYTE(0x11)
+    SHORT(0x1122)
+    LONG(0x11223344)
+    QUAD(0x1122334455667788)
+    . += 0x1000;
+    *(.foo.1)
+    . += 0x123 *
+         (1 + 1);
+    foo = .;
+    bar = 0x42 - 0x26;
+  }
+}
+
+# CHECK:      Address          Size             Align Out     In      Symbol
+# CHECK-NEXT: 0000000000001000 000000000000125d     1 .foo
+# CHECK-NEXT: 0000000000001000 0000000000000001     1         BYTE ( 0x11 )
+# CHECK-NEXT: 0000000000001001 0000000000000002     1         SHORT ( 0x1122 )
+# CHECK-NEXT: 0000000000001003 0000000000000004     1         LONG ( 0x11223344 )
+# CHECK-NEXT: 0000000000001007 0000000000000008     1         QUAD ( 0x1122334455667788 )
+# CHECK-NEXT: 000000000000100f 0000000000001000     1         . += 0x1000
+# CHECK-NEXT: 000000000000200f 0000000000000008     1         {{.*}}{{/|\\}}map-file.test.tmp.o:(.foo.1)
+# CHECK-NEXT: 0000000000002017 0000000000000246     1         . += 0x123 * ( 1 + 1 )
+# CHECK-NEXT: 000000000000225d 0000000000000000     1         foo = .
+# CHECK-NEXT: 000000000000225d 0000000000000000     1         bar = 0x42 - 0x26
+# CHECK-NEXT: 0000000000002260 0000000000000000     4 .text
+# CHECK-NEXT: 0000000000002260 0000000000000000     4         {{.*}}{{/|\\}}map-file.test.tmp.o:(.text)