[LLD][ELF] Add support for INPUT_SECTION_FLAGS

[peter.smith]

Summary

The INPUT_SECTION_FLAGS linker script command is used to constrain the section pattern matching to sections that match certain combinations of flags.

There are two ways to express the constraint.

• withFlags: Section must have these flags.
• withoutFlags: Section must not have these flags.

The syntax of the command is:

INPUT_SECTION_FLAGS '(' sect_flag_list ')'
sect_flag_list: NAME
| sect_flag_list '&' NAME

Where NAME matches a section flag name such as SHF_EXECINSTR, or the integer value of a section flag. If the first character of NAME is ! then it means must not contain flag.
As an example from the ld man page: https://sourceware.org/binutils/docs/ld/Input-Section-Basics.html

SECTIONS {
  .text : { INPUT_SECTION_FLAGS (SHF_MERGE & SHF_STRINGS) *(.text) }
  .text2 :  { INPUT_SECTION_FLAGS (!SHF_WRITE) *(.text) }
}

• .text will match sections called .text that have both the SHF_MERGE and SHF_STRINGS flag.
• .text2 will match sections called .text that don't have the SHF_WRITE flag.

The flag names accepted are the generic to all targets and SHF_ARM_PURECODE as it is very useful to filter all the pure code sections into a single program header that can be marked execute never.

fixes PR44265 https://bugs.llvm.org/show_bug.cgi?id=44265

The GNU ld documentation for this feature is limited to the link above. I found the grammar https://github.com/bminor/binutils-gdb/blob/master/ld/ldgram.y clear enough, particularly sect_flags.

As I see it the main use case for INPUT_SECTION_FLAGS is porting projects from other linkers that primarily match by section flags rather than by name. For example Arm's proprietary linker scatter file notation uses notation like:

RO 0x8000 { *(+ro) }
RW +0 { *(+rw, +zi) }

Projects moving to linker scripts have to approximate this by section name and this can be a challenge. The INPUT_SECTION_FLAGS can ease this transition.

[grimar]

First round of comments from me.
I mostly was focused on "is it possible to simplify the implementation for start?" question.

lld/ELF/LinkerScript.h

159

I wonder, can we have something like flagsMask here and everywhere instead of two variables?

lld/ELF/ScriptParser.cpp

1137

Are integers used in the wild? I wonder if we can stick to supporting named flags only,
it should be easier to read scripts I think.

1165

This is perhaps not a best idea how to handle flags?
I guess we should not accept MIPS flags for non-mips targets and so on?
(I see that we probably do not know the target plafrorm at this point, I think).

I wonder, can we just support a generic set for start? Will it be enough?
I.e. write/alloc/exec flags (+something else)?

1187

This probably is not correct way. What if we have a different unexpected token here, like "+"?
It seems you should be able to remove this setError.

1192

You need to print the value I think.

lld/test/ELF/input-section-flags.s

98

I'd suggest to rename sections instead.
To: .sec.a, .sec.ax, etc.

Because such comments are not really useful by themselves probably?

[peter.smith]

Thanks for the comments, I'll make an update tomorrow. I'll plan to:

• Try the flagsMask + withMask to see if it looks any better.
• Limit the recognised flags to what BFD accepts, I'd like to continue to recognise integers.
• Look at the error reporting in the parser.
• Update the tests.

lld/ELF/LinkerScript.h

159

I couldn't think of a way of doing it with just one flagsMask as for each flag bit there are 3 states (don't care, required set, required not-set) and with a single mask we've only got 2. An alternative to the above is to use flagsMask and withMask. Both with and without would add to flagsMask, but only with would add to withMask. Then to check we have just.

(sec->flags | flagsMask) == withMask;

That saves a comparison at, I guess a slight cost to readability, but we'd still need two values. Happy to change to that if you'd prefer it. Open to alternative suggestions about how to represent it.

lld/ELF/ScriptParser.cpp

1137

I've not seen them used, but it does offer an instant workaround if a new flag is added in a future release, or a more limited set of flags is chosen to be accepted.

1165

I'd be happy with that, although I'd prefer we supported integers in that case as then if we'd not included someone's favourite flag they can still use it. The GNU linker supports:

{ "SHF_WRITE", SHF_WRITE },
{ "SHF_ALLOC", SHF_ALLOC },
{ "SHF_EXECINSTR", SHF_EXECINSTR },
{ "SHF_MERGE", SHF_MERGE },
{ "SHF_STRINGS", SHF_STRINGS },
{ "SHF_INFO_LINK", SHF_INFO_LINK},
{ "SHF_LINK_ORDER", SHF_LINK_ORDER},
{ "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
{ "SHF_GROUP", SHF_GROUP },
{ "SHF_TLS", SHF_TLS },
{ "SHF_MASKOS", SHF_MASKOS },
{ "SHF_EXCLUDE", SHF_EXCLUDE },

Which is pretty much just the generic ones. I know SHF_ARM_PURECODE would be really useful, but that could be represented as an integer.

1187

Agreed I'll rethink and see if I can come up with something better.

1192

Agreed, thanks for the suggestion

lld/test/ELF/input-section-flags.s

98

OK, I'll update.

[MaskRay]

lld/ELF/LinkerScript.cpp

436–439

This may need a rebase if D72775 lands first.

lld/ELF/LinkerScript.h

159

The transformation is (sec->flag | dont-care) = (withMask | dont-care), i.e.

(sec->flags | ~(withMask | withoutMask)) == (withMask | ~(withMask | withoutMask))

It harms readability and unlikely improves performance.

lld/ELF/ScriptParser.cpp

1165

We can do something like tools/llvm-readobj/ELFDumper.cpp:

#define ENUM_ENT(enum) { #enum, ELF::enum }

ENUM_ENT(SHF_WRITE)
ENUM_ENT(SHF_ALLOC)

I agree that the generic ones plus SHF_ARM_PURECODE should be sufficient.

lld/test/ELF/input-section-flags-diag1.test

3

Nit: -unknown-linux -> ``(This is generic, not Linux specific)

4

%t -> /dev/null

lld/test/ELF/input-section-flags-diag2.test

4

%t -> /dev/null

lld/test/ELF/input-section-flags.s

5

##

12

Nit: Indent continuation lines.

[peter.smith]

Thanks for the comments, I'll upload a new patch shortly.

lld/ELF/LinkerScript.cpp

436–439

I've rebased as D72775 has landed.

lld/ELF/LinkerScript.h

159

Thanks, I'll leave it as it is for now.

lld/ELF/ScriptParser.cpp

1165

I'll implement using ENUM_ENT and will restrict to generic + SHF_ARM_PURECODE. I don't think that it is that important to filter the available flags by Target as we are mapping unique name to value and we're not mapping back from non-unique value to name.

I've kept the ability to accept an int for now. Happy to remove if you'd prefer, given it reuses an existing function it is not a lot of extra effort to include.

lld/test/ELF/input-section-flags-diag1.test

3

will fix.

4

will fix

lld/test/ELF/input-section-flags-diag2.test

4

Will fix.

lld/test/ELF/input-section-flags.s

5

will fix

12

Will fix.

[peter.smith]

Address code review comments so far. Main changes:

• Rebased
• Used EnumEntry as in ELFDumper.cpp
• Updated parser with better diagnostic message
• Updated tests

[MaskRay]

lld/ELF/ScriptParser.cpp

864

Mis-indented.

1165

Accept an integer is a nice extension.

The loop can be simplified as:

while (!errorCount()) {
  StringRef tok = unquote(next());
  bool without = tok.consume_front("!");
  if (llvm::Optional<uint64_t> flag = parseFlag(tok)) {
    if (without)
      withoutFlags |= *flag;
    else
      withFlags |= *flag;
  } else {
    setError("unrecognised flag: " + tok);
  }
  if (consume(")"))
    break;
  if (!consume("&")) {
    next();
    setError("expected & or )");
  }
}

[grimar]

lld/ELF/ScriptParser.cpp

709

I think more natural way is to use consume:

if (consume("INPUT_SECTION_FLAGS"))
  std::tie(withFlags, withoutFlags) = readInputSectionFlags();

StringRef filePattern = next();
...

804

The same.

863

We parse "KEEP" in readInputSectionDescription, and you handle "INPUT_SECTION_FLAGS" for it right there.
Seems you can remove handling of "INPUT_SECTION_FLAGS" from here and move it to readInputSectionDescription too
(for the no-KEEP case).

This should allow avoid having withFlags = withoutFlags = 0; code (and variables itself) around.

1146

May be use llvm::StringSwitch instead?

[grimar]

lld/ELF/ScriptParser.cpp

1146

To clarify: StringSwitch looks probably much simpler than a combination of EnumEntry<unsigned> array + llvm::find_if.
So it seems could be:

 return StringSwitch<llvm::Optional<uint64_t>> (tok)
   .Case("SHF_WRITE", ELF::SHF_WRITE)
...

or

 return StringSwitch<llvm::Optional<uint64_t>> (tok)
   .Case(ENUM_ENT(SHF_WRITE))
...

(If we want to use defines. I am not sure in that, given that the number of flags is not so large now,
but have no strong objections)

Both ways still look better probably?

[peter.smith]

Thanks for the review. I'll upload another patch that I hope to have addressed all the comments.

lld/ELF/ScriptParser.cpp

709

Thanks for the suggestion, have applied and also in readOverlayDescription.

863

On my first attempt I had the logic in readInputSectionDescription. The problem I found was with the no section description case matched in:

else {
      // We have a file name and no input sections description. It is not a
      // commonly used syntax, but still acceptable. In that case, all sections
      // from the file will be included.
}

As INPUT_SECTION_DESCRIPTION always has parentheses it is matched by

else if (peek() == "(")

So if I write:

{ INPUT_SECTION_DESCRIPTION(some flag list) filespec }

it matches the else if (peek() == "("). Unfortunately the above is not easily distinguishable from:

{ INPUT_SECTION_DESCRIPTION(some flag list) filespec(inputsectiondescription) }

I couldn't think of an easy way of distinguishing between these two cases at this level. I'm open to suggestions as I'm not keen on having to clear the state.

1146

I've rewritten using StringSwitch, thanks for the suggestion, I think it looks simpler.

1165

Thanks for the suggestion, I've applied.

[peter.smith]

Updated diff. Main changes:

• Use stringswitch with enumerations
• Incorporate simplification suggestions

[grimar]

lld/ELF/ScriptParser.cpp

712

I think you can now get rid of tok = next();:

InputSectionDescription *cmd =
  readInputSectionRules(next(), withFlags, withoutFlags);

804

And here.

863

I see now, thanks.
There seems to be another problem of having "INPUT_SECTION_FLAGS" here:

I think that scripts like
"{ INPUT_SECTION_DESCRIPTION(list1) INPUT_SECTION_DESCRIPTION(list2) <the_rest_part>}" are accepted?
It is not good.

The solution I have in mind is to refactor the following code

// We have a file name and no input sections description. It is not a
// commonly used syntax, but still acceptable. In that case, all sections
// from the file will be included.
auto *isd = make<InputSectionDescription>(tok, withFlags, withoutFlags);
isd->sectionPatterns.push_back({{}, StringMatcher({"*"})});
cmd->sectionCommands.push_back(isd);
withFlags = withoutFlags = 0;

Into a different function that will also try to handle INPUT_SECTION_FLAGS. Sounds like it might work?
I am happy to try to experiment with this (or another approaches), but would like to clarify:

1. Do we need/want to support this case? "We have a file name and no input sections description" case seems to be corner case (I am not sure how often it is used). And it is not clear if other linkers support this combination. I quess it is probably a reasonable one though.
2. If we want it, then the question is: how much it is important to support this from start? It seems that leaving it for a follow-up patch (and changing this place to "first attemp logic" for now) can be a reasonable solution to proceed for now.

lld/test/ELF/input-section-flags-diag3.test

6

Seems it belongs to a different test case and needs an update?

[grimar]

lld/ELF/ScriptParser.cpp

863

The solution I have in mind is to refactor the following code

Ah, and this will not work because of the reason you've mentioned. Sorry.
I'd really leave this corner-case for a follow-up patch I think.

[peter.smith]

I'll remove the support for the corner-case of when there is just a filepattern. Most likely won't get the time today, if I don't then I'll update on Monday. Thanks for the comments.

lld/ELF/ScriptParser.cpp

712

I don't think I can, that line is the same as line 699 in the diff on the left hand side.

StringRef filePattern = next();
if (consume("INPUT_SECTION_FLAGS"))

I think I can rename tok to filePattern though.

863

I was just following the ld.bfd grammar, so I'm happy to remove it and leave it for a follow up patch if it were necessary.

lld/test/ELF/input-section-flags-diag3.test

6

Thanks I'll update the comment.

[peter.smith]

• Removed support for corner case where there is just a filespec. This permits the INPUT_SECTION_FLAGS logic to be moved to readInputSectionDescription from readOutputSectionDescription.
• Changed comment in test

[MaskRay]

lld/test/ELF/input-section-flags.s

52

Indent .outsec*

66

Indent .outsec1

[grimar]

I've put a few suggestions, but generally this LGTM. Thanks!

lld/ELF/ScriptParser.cpp

712

Not sure I understand why there can be any problems with the following code?

if (consume("INPUT_SECTION_FLAGS"))
   std::tie(withFlags, withoutFlags) = readInputSectionFlags();
 InputSectionDescription *cmd =
     readInputSectionRules(next(), withFlags, withoutFlags);

(I tried and it works)
You do not use tok below the readInputSectionRules anyways.

The original code had the StringRef filePattern variable.
I am not sure how much useful to have it,
but at least it named the token somehow.

But in the following version

tok = next();
InputSectionDescription *cmd =
    readInputSectionRules(tok, withFlags, withoutFlags);

I do not see why it might be useful to do tok = next(); and not just inline the next()?

So I'd suggest to write in one of the following ways:

if (consume("INPUT_SECTION_FLAGS"))
   std::tie(withFlags, withoutFlags) = readInputSectionFlags();
 InputSectionDescription *cmd =
     readInputSectionRules(next(), withFlags, withoutFlags);

or stick to the original code:

if (consume("INPUT_SECTION_FLAGS"))
  std::tie(withFlags, withoutFlags) = readInputSectionFlags();
StringRef filePattern = next();
InputSectionDescription *cmd =
    readInputSectionRules(filePattern, withFlags, withoutFlags);

723

I'd suggest to early return in the "INPUT_SECTION_FLAGS" branch just like we do in the "KEEP" branch.
It seems probably a bit simpler to exit early here too?

if (tok == "INPUT_SECTION_FLAGS") {
  std::tie(withFlags, withoutFlags) = readInputSectionFlags();
  return readInputSectionRules(next(), withFlags, withoutFlags);
}
return readInputSectionRules(tok, withFlags, withoutFlags);

804

This comment was missed. Here you can inline the next() call too:

if (consume("INPUT_SECTION_FLAGS"))
  std::tie(withFlags, withoutFlags) = readInputSectionFlags();
cmd->sectionCommands.push_back(
    readInputSectionRules(next(), withFlags, withoutFlags));

This is what original code did, btw.

[MaskRay]

lld/ELF/ScriptParser.cpp

723

tok = next(); looks fine to me.. The return statement will become complex with the change.

[peter.smith]

Thanks for the comments. It has been a bit of a nightmare of a day and I've only just got to this. I'll apply the suggestions and commit tomorrow morning so I can catch any problems.

lld/ELF/ScriptParser.cpp

712

I see now, I missed the inlining of next(), I'll update to do

if (consume("INPUT_SECTION_FLAGS"))
   std::tie(withFlags, withoutFlags) = readInputSectionFlags();
 InputSectionDescription *cmd =
     readInputSectionRules(next(), withFlags, withoutFlags);

723

I'll keep as it is for the moment.

804

Apologies for missing it, I'll update to inline.

lld/ELF/LinkerScript.h

struct SectionPattern {
 
   StringMatcher excludedFilePat;
   StringMatcher sectionPat;
   SortSectionPolicy sortOuter;
   SortSectionPolicy sortInner;
 };
 
 struct InputSectionDescription : BaseCommand {
-  InputSectionDescription(StringRef filePattern)
-      : BaseCommand(InputSectionKind), filePat(filePattern) {}
+  InputSectionDescription(StringRef filePattern, uint64_t withFlags = 0,
+                          uint64_t withoutFlags = 0)
+      : BaseCommand(InputSectionKind), filePat(filePattern),
+        withFlags(withFlags), withoutFlags(withoutFlags) {}
 
   static bool classof(const BaseCommand *c) {
     return c->kind == InputSectionKind;
   }
 
   StringMatcher filePat;
 
   // Input sections that matches at least one of SectionPatterns
   // will be associated with this InputSectionDescription.
   std::vector<SectionPattern> sectionPatterns;
 
   // Includes InputSections and MergeInputSections. Used temporarily during
   // assignment of input sections to output sections.
   std::vector<InputSectionBase *> sectionBases;
 
   // Used after the finalizeInputSections() pass. MergeInputSections have been
   // merged into MergeSyntheticSections.
   std::vector<InputSection *> sections;
 
   // Temporary record of synthetic ThunkSection instances and the pass that
   // they were created in. This is used to insert newly created ThunkSections
   // into Sections at the end of a createThunks() pass.
   std::vector<std::pair<ThunkSection *, uint32_t>> thunkSections;
+
+  // SectionPatterns can be filtered with the INPUT_SECTION_FLAGS command.
+  uint64_t withFlags;
+  uint64_t withoutFlags;
 };
 
 // Represents BYTE(), SHORT(), LONG(), or QUAD().
 struct ByteCommand : BaseCommand {
   ByteCommand(Expr e, unsigned size, std::string commandString)
       : BaseCommand(ByteKind), commandString(commandString), expression(e),
         size(size) {}
 

lld/ELF/LinkerScript.cpp

 
 bool LinkerScript::shouldKeep(InputSectionBase *s) {
   if (keptSections.empty())
     return false;
   std::string filename = getFilename(s->file);
   for (InputSectionDescription *id : keptSections)
     if (id->filePat.match(filename))
       for (SectionPattern &p : id->sectionPatterns)
-        if (p.sectionPat.match(s->name))
+        if (p.sectionPat.match(s->name) &&
+            (s->flags & id->withFlags) == id->withFlags &&
+            (s->flags & id->withoutFlags) == 0)
           return true;
   return false;
 }
 
 // A helper function for the SORT() command.
 static bool matchConstraints(ArrayRef<InputSectionBase *> sections,
                              ConstraintKind kind) {
   if (kind == ConstraintKind::NoConstraint)
for (InputSectionBase *sec : inputSections) {
           cast<InputSection>(sec)->getRelocatedSection())
         continue;
 
       // Check the name early to improve performance in the common case.
       if (!pat.sectionPat.match(sec->name))
         continue;
 
       std::string filename = getFilename(sec->file);
-      if (!cmd->filePat.match(filename) || pat.excludedFilePat.match(filename))
+      if (!cmd->filePat.match(filename) ||
+          pat.excludedFilePat.match(filename) ||
+          (sec->flags & cmd->withFlags) != cmd->withFlags ||
+          (sec->flags & cmd->withoutFlags) != 0)
         continue;
 
       ret.push_back(sec);
     }
 
     sortInputSections(
         MutableArrayRef<InputSectionBase *>(ret).slice(sizeBefore), pat);
   }

lld/ELF/ScriptParser.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include <cassert>
 #include <limits>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::support::endian;
 
private:
   ByteCommand *readByteCommand(StringRef tok);
   std::array<uint8_t, 4> readFill();
   bool readSectionDirective(OutputSection *cmd, StringRef tok1, StringRef tok2);
   void readSectionAddressType(OutputSection *cmd);
   OutputSection *readOverlaySectionDescription();
   OutputSection *readOutputSectionDescription(StringRef outSec);
   std::vector<BaseCommand *> readOverlay();
   std::vector<StringRef> readOutputSectionPhdrs();
-  InputSectionDescription *readInputSectionDescription(StringRef tok);
+  std::pair<uint64_t, uint64_t> readInputSectionFlags();
+  InputSectionDescription *readInputSectionDescription(StringRef tok,
+                                                       uint64_t withFlags,
+                                                       uint64_t withoutFlags);
   StringMatcher readFilePatterns();
   std::vector<SectionPattern> readInputSectionsList();
-  InputSectionDescription *readInputSectionRules(StringRef filePattern);
+  InputSectionDescription *readInputSectionRules(StringRef filePattern,
+                                                 uint64_t withFlags,
+                                                 uint64_t withoutFlags);
   unsigned readPhdrType();
   SortSectionPolicy readSortKind();
   SymbolAssignment *readProvideHidden(bool provide, bool hidden);
   SymbolAssignment *readAssignment(StringRef tok);
   void readSort();
   Expr readAssert();
   Expr readConstant();
   Expr getPageSize();

 //              | <sort> "(" <section-list> ")"
 //              | <sort> "(" <sort> "(" <section-list> ")" ")"
 //
 // <sort>     ::= "SORT" | "SORT_BY_NAME" | "SORT_BY_ALIGNMENT"
 //              | "SORT_BY_INIT_PRIORITY" | "SORT_NONE"
 //
 // <section-list> is parsed by readInputSectionsList().
 InputSectionDescription *
-ScriptParser::readInputSectionRules(StringRef filePattern) {
-  auto *cmd = make<InputSectionDescription>(filePattern);
+ScriptParser::readInputSectionRules(StringRef filePattern, uint64_t withFlags,
+                                    uint64_t withoutFlags) {
+  auto *cmd =
+      make<InputSectionDescription>(filePattern, withFlags, withoutFlags);
   expect("(");
 
   while (!errorCount() && !consume(")")) {
     SortSectionPolicy outer = readSortKind();
     SortSectionPolicy inner = SortSectionPolicy::Default;
     std::vector<SectionPattern> v;
     if (outer != SortSectionPolicy::Default) {
       expect("(");
while (!errorCount() && !consume(")")) {
     }
 
     std::move(v.begin(), v.end(), std::back_inserter(cmd->sectionPatterns));
   }
   return cmd;
 }
 
 InputSectionDescription *
-ScriptParser::readInputSectionDescription(StringRef tok) {
+ScriptParser::readInputSectionDescription(StringRef tok, uint64_t withFlags,
+                                          uint64_t withoutFlags) {
   // Input section wildcard can be surrounded by KEEP.
   // https://sourceware.org/binutils/docs/ld/Input-Section-Keep.html#Input-Section-Keep
   if (tok == "KEEP") {
     expect("(");
-    StringRef filePattern = next();
-    InputSectionDescription *cmd = readInputSectionRules(filePattern);
+    StringRef tok = next();
+    if (tok == "INPUT_SECTION_FLAGS") {
+      std::tie(withFlags, withoutFlags) = readInputSectionFlags();
+      tok = next();
+    }
+    InputSectionDescription *cmd =
+        readInputSectionRules(tok, withFlags, withoutFlags);
     expect(")");
     script->keptSections.push_back(cmd);
     return cmd;
   }
-  return readInputSectionRules(tok);
+  return readInputSectionRules(tok, withFlags, withoutFlags);
 }
 
 void ScriptParser::readSort() {
   expect("(");
   expect("CONSTRUCTORS");
   expect(")");
 }
 
 Expr ScriptParser::readAssert() {
   expect("(");
   Expr e = readExpr();
   expect(",");
static Expr checkAlignment(Expr e, std::string &loc) {
   };
 }
 
 OutputSection *ScriptParser::readOverlaySectionDescription() {
   OutputSection *cmd =
       script->createOutputSection(next(), getCurrentLocation());
   cmd->inOverlay = true;
   expect("{");
-  while (!errorCount() && !consume("}"))
-    cmd->sectionCommands.push_back(readInputSectionRules(next()));
-  cmd->phdrs = readOutputSectionPhdrs();
+  while (!errorCount() && !consume("}")) {
+    uint64_t withFlags = 0;
+    uint64_t withoutFlags = 0;
+    StringRef tok = next();
+    if (tok == "INPUT_SECTION_FLAGS") {
+      std::tie(withFlags, withoutFlags) = readInputSectionFlags();
+      tok = next();
+    }
+    cmd->sectionCommands.push_back(
+        readInputSectionRules(tok, withFlags, withoutFlags));
+  }
   return cmd;
 }
 
 OutputSection *ScriptParser::readOutputSectionDescription(StringRef outSec) {
   OutputSection *cmd =
       script->createOutputSection(outSec, getCurrentLocation());
 
   size_t symbolsReferenced = script->referencedSymbols.size();
OutputSection *ScriptParser::readOutputSectionDescription(StringRef outSec) {
 
   // Parse constraints.
   if (consume("ONLY_IF_RO"))
     cmd->constraint = ConstraintKind::ReadOnly;
   if (consume("ONLY_IF_RW"))
     cmd->constraint = ConstraintKind::ReadWrite;
   expect("{");
 
+  uint64_t withFlags = 0;
+  uint64_t withoutFlags = 0;
+
   while (!errorCount() && !consume("}")) {
     StringRef tok = next();
     if (tok == ";") {
       // Empty commands are allowed. Do nothing here.
     } else if (SymbolAssignment *assign = readAssignment(tok)) {
       cmd->sectionCommands.push_back(assign);
     } else if (ByteCommand *data = readByteCommand(tok)) {
       cmd->sectionCommands.push_back(data);
     } else if (tok == "CONSTRUCTORS") {
       // CONSTRUCTORS is a keyword to make the linker recognize C++ ctors/dtors
       // by name. This is for very old file formats such as ECOFF/XCOFF.
       // For ELF, we should ignore.
     } else if (tok == "FILL") {
       // We handle the FILL command as an alias for =fillexp section attribute,
       // which is different from what GNU linkers do.
       // https://sourceware.org/binutils/docs/ld/Output-Section-Data.html
       expect("(");
       cmd->filler = readFill();
       expect(")");
     } else if (tok == "SORT") {
       readSort();
     } else if (tok == "INCLUDE") {
       readInclude();
+    } else if (tok == "INPUT_SECTION_FLAGS") {
+        std::tie(withFlags, withoutFlags) = readInputSectionFlags();
     } else if (peek() == "(") {
-      cmd->sectionCommands.push_back(readInputSectionDescription(tok));
+      cmd->sectionCommands.push_back(
+          readInputSectionDescription(tok, withFlags, withoutFlags));
+      withFlags = withoutFlags = 0;
     } else {
       // We have a file name and no input sections description. It is not a
       // commonly used syntax, but still acceptable. In that case, all sections
       // from the file will be included.
-      auto *isd = make<InputSectionDescription>(tok);
+      auto *isd = make<InputSectionDescription>(tok, withFlags, withoutFlags);
       isd->sectionPatterns.push_back({{}, StringMatcher({"*"})});
       cmd->sectionCommands.push_back(isd);
+      withFlags = withoutFlags = 0;
     }
   }
 
   if (consume(">"))
     cmd->memoryRegionName = next();
 
   if (consume("AT")) {
     expect(">");
ByteCommand *ScriptParser::readByteCommand(StringRef tok) {
   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);
 }
 
+static llvm::Optional<uint64_t> parseFlag(StringRef tok) {
+#define ENUM_ENT(enum) {#enum, ELF::enum}
+  EnumEntry<unsigned> elfSectionFlags[] = {
+      ENUM_ENT(SHF_WRITE),        ENUM_ENT(SHF_ALLOC),
+      ENUM_ENT(SHF_EXECINSTR),    ENUM_ENT(SHF_MERGE),
+      ENUM_ENT(SHF_STRINGS),      ENUM_ENT(SHF_INFO_LINK),
+      ENUM_ENT(SHF_LINK_ORDER),   ENUM_ENT(SHF_OS_NONCONFORMING),
+      ENUM_ENT(SHF_GROUP),        ENUM_ENT(SHF_TLS),
+      ENUM_ENT(SHF_COMPRESSED),   ENUM_ENT(SHF_EXCLUDE),
+      ENUM_ENT(SHF_ARM_PURECODE),
+  };
+#undef ENUM_ENT
+  if (llvm::Optional<uint64_t> asInt = parseInt(tok))
+    return asInt;
+  ArrayRef<const EnumEntry<unsigned>> flags(elfSectionFlags);
+  auto I = llvm::find_if(
+      flags, [=](const EnumEntry<unsigned> &E) { return tok == E.Name; });
+  if (I == flags.end())
+    return None;
+  return I->Value;
+}
+
+// Reads the '(' <flags> ')' list of section flags in
+// INPUT_SECTION_FLAGS '(' <flags> ')' in the
+// following form:
+// <flags> ::= <flag>
+//           | <flags> & flag
+// <flag>  ::= Recognized Flag Name, or Integer value of flag.
+// If the first character of <flag> is a ! then this means without flag,
+// otherwise with flag.
+// Example: SHF_EXECINSTR & !SHF_WRITE means with flag SHF_EXECINSTR and
+// without flag SHF_WRITE.
+std::pair<uint64_t, uint64_t> ScriptParser::readInputSectionFlags() {
+  bool expectName = true;
+  uint64_t withFlags = 0;
+  uint64_t withoutFlags = 0;
+  expect("(");
+  while (!atEOF() && !errorCount()) {
+    if (expectName) {
+      StringRef tok = unquote(next());
+      bool without = tok.consume_front("!");
+      llvm::Optional<uint64_t> flag = parseFlag(tok);
+      if (!flag)
+        setError("unrecognised flag: " + tok);
+      else {
+        if (without)
+          withoutFlags |= *flag;
+        else
+          withFlags |= *flag;
+      }
+      expectName = false;
+    } else {
+      if (consume("&")) {
+        expectName = true;
+        continue;
+      }
+      if (consume(")"))
+        break;
+      else {
+        next();
+        setError("expected & or )");
+      }
+    }
+  }
+  return std::make_pair(withFlags, withoutFlags);
+}
+
 StringRef ScriptParser::readParenLiteral() {
   expect("(");
   bool orig = inExpr;
   inExpr = false;
   StringRef tok = next();
   inExpr = orig;
   expect(")");
   return tok;

lld/test/ELF/input-section-flags-diag1.test

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 /dev/null -o %t.o
+# RUN: not ld.lld -shared %t.o -o /dev/null --script %s 2>&1 | FileCheck -strict-whitespace %s
+
+## Check that the section flag is recognized.
+
+SECTIONS {
+ .text : { INPUT_SECTION_FLAGS(UNKNOWN_FLAG) *(.text) }
+}
+
+# CHECK: unrecognised flag: UNKNOWN_FLAG
+# CHECK-NEXT: >>>  .text : { INPUT_SECTION_FLAGS(UNKNOWN_FLAG) *(.text) }
+# CHECK-NEXT: >>>                                ^

lld/test/ELF/input-section-flags-diag2.test

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 /dev/null -o %t.o
+# RUN: not ld.lld -shared %t.o -o /dev/null --script %s 2>&1 | FileCheck -strict-whitespace %s
+
+## Check that we start with a flag
+
+SECTIONS {
+ .text : { INPUT_SECTION_FLAGS(& SHF_ALLOC) *(.text) }
+}
+
+# CHECK:  unrecognised flag: &
+# CHECK-NEXT: >>>  .text : { INPUT_SECTION_FLAGS(& SHF_ALLOC) *(.text) }
+# CHECK-NEXT: >>>                                ^

lld/test/ELF/input-section-flags-diag3.test

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 /dev/null -o %t.o
+# RUN: not ld.lld -shared %t.o -o /dev/null --script %s 2>&1 | FileCheck -strict-whitespace %s
+
+## Check that we start with a flag
+
+SECTIONS {
+ .text : { INPUT_SECTION_FLAGS(SHF_ALLOC SHF_EXECINSTR) *(.text) }
+}
+
+// CHECK: expected & or )
+// CHECK-NEXT: >>>  .text : { INPUT_SECTION_FLAGS(SHF_ALLOC SHF_EXECINSTR) *(.text) }
+// CHECK-NEXT: >>>                                          ^

lld/test/ELF/input-section-flags-keep.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+# RUN: echo "SECTIONS { \
+# RUN:  . = SIZEOF_HEADERS; \
+# RUN:  .keep : { KEEP( INPUT_SECTION_FLAGS(!SHF_WRITE) *(.sec*)) } \
+# RUN:  }" > %t.script
+# RUN: ld.lld --gc-sections -o %t --script %t.script %t.o
+# RUN: llvm-readobj --symbols %t | FileCheck %s
+
+## Check that INPUT_SECTION_FLAGS can be used within KEEP, and affects what
+## is kept.
+# CHECK: Name: keep
+# CHECK-NOT: NAME: collect
+.text
+.global _start
+_start:
+ .long 0
+
+.section .sec1, "a"
+.global keep
+keep:
+ .long 1
+
+.section .sec2, "aw"
+.global collect
+collect:
+ .long 2

lld/test/ELF/input-section-flags.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+
+## Test the INPUT_SECTION_FLAGS feature. It prefixes an input section list and
+## restricts matches to sections that have the required flags and do not have
+## any of the must not have flags.
+
+## Uniquely identify each .sec section by flag alone, with .text going into
+## to the SHF_EXECINSTR requiring .outsec2
+# RUN: echo "SECTIONS { \
+# RUN: .outsec1 : { INPUT_SECTION_FLAGS(SHF_ALLOC & !SHF_EXECINSTR & \
+# RUN:                                  !SHF_WRITE & !SHF_MERGE) *(.sec.*) } \
+# RUN: .outsec2 : { INPUT_SECTION_FLAGS(SHF_ALLOC & SHF_EXECINSTR & !SHF_WRITE\
+# RUN:                                  & !SHF_MERGE) *(.sec.* .text) } \
+# RUN: .outsec3 : { INPUT_SECTION_FLAGS(SHF_WRITE) *(.sec.*) } \
+# RUN: .outsec4 : { INPUT_SECTION_FLAGS(SHF_MERGE & !SHF_STRINGS) *(.sec.*) } \
+# RUN: .outsec5 : { INPUT_SECTION_FLAGS(SHF_STRINGS) *(.sec.*) } \
+# RUN: } " > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t.o
+# RUN: llvm-readobj --symbols %t1 | FileCheck %s
+# CHECK:  Name: _start
+# CHECK:  Section: .outsec2
+# CHECK:  Name: s1
+# CHECK:  Section: .outsec1
+# CHECK:  Name: s2
+# CHECK:  Section: .outsec2
+# CHECK:  Name: s3
+# CHECK:  Section: .outsec3
+# CHECK:  Name: s4
+# CHECK:  Section: .outsec4
+# CHECK:  Name: s5
+# CHECK:  Section: .outsec5
+
+## Same test but using just a filespec.
+# RUN: echo "SECTIONS { \
+# RUN: .outsec1 : { INPUT_SECTION_FLAGS(SHF_ALLOC & !SHF_EXECINSTR & \
+# RUN:                                  !SHF_WRITE & !SHF_MERGE) *.o }\
+# RUN: .outsec2 : { INPUT_SECTION_FLAGS(SHF_ALLOC & SHF_EXECINSTR & !SHF_WRITE\
+# RUN:                                  & !SHF_MERGE) *.o } \
+# RUN: .outsec3 : { INPUT_SECTION_FLAGS(SHF_WRITE) *.o } \
+# RUN: .outsec4 : { INPUT_SECTION_FLAGS(SHF_MERGE & !SHF_STRINGS) * } \
+# RUN: .outsec5 : { INPUT_SECTION_FLAGS(SHF_STRINGS) * } \
+# RUN: } " > %t2.script
+
+# RUN: ld.lld -o %t2 --script %t2.script %t.o
+# RUN: llvm-readobj --symbols %t2 | FileCheck %s
+
+## Same test but using OVERLAY.
+# RUN: echo "SECTIONS { \
+# RUN: OVERLAY 0x1000 : AT ( 0x4000 ) { \
+# RUN: .outsec1 { INPUT_SECTION_FLAGS(SHF_ALLOC & !SHF_EXECINSTR & \
+# RUN:                                !SHF_WRITE & !SHF_MERGE) *(.sec.*) }\
+# RUN: .outsec2 { INPUT_SECTION_FLAGS(SHF_ALLOC & SHF_EXECINSTR & !SHF_WRITE \
+# RUN:                                & !SHF_MERGE) *(.sec.* .text) } \
+# RUN: .outsec3 { INPUT_SECTION_FLAGS(SHF_WRITE) *(.sec.*) } \
+# RUN: .outsec4 { INPUT_SECTION_FLAGS(SHF_MERGE & !SHF_STRINGS) *(.sec.*) } \
+# RUN: .outsec5 { INPUT_SECTION_FLAGS(SHF_STRINGS) *(.sec.*) } \
+# RUN: } } " > %t3.script
+
+# RUN: ld.lld -o %t3 --script %t3.script %t.o
+# RUN: llvm-readobj --symbols %t3 | FileCheck %s
+
+## Same test but using hex representations of the flags.
+# RUN: echo "SECTIONS { \
+# RUN: .outsec1 : { INPUT_SECTION_FLAGS(0x2 & !0x4 & !0x1 & !0x10) *(.sec.*) }\
+# RUN: .outsec2 : { INPUT_SECTION_FLAGS(0x2 & 0x4 & !0x1 & !0x10) \
+# RUN:              *(.sec.* .text) } \
+# RUN: .outsec3 : { INPUT_SECTION_FLAGS(0x1) *(.sec.*) } \
+# RUN: .outsec4 : { INPUT_SECTION_FLAGS(0x10 & !0x20) *(.sec.*) } \
+# RUN: .outsec5 : { INPUT_SECTION_FLAGS(0x20) *(.sec.*) } \
+# RUN: } " > %t4.script
+
+# RUN: ld.lld -o %t4 --script %t4.script %t.o
+# RUN: llvm-readobj --symbols %t4 | FileCheck %s
+
+## Check that we can handle multiple InputSectionDescriptions in a single
+## OutputSection
+# RUN: echo "SECTIONS { \
+# RUN: .outsec1 : { INPUT_SECTION_FLAGS(SHF_ALLOC & !SHF_EXECINSTR & \
+# RUN:                                  !SHF_WRITE & !SHF_MERGE) *(.sec.*) ; \
+# RUN:              INPUT_SECTION_FLAGS(SHF_ALLOC & SHF_EXECINSTR & !SHF_WRITE\
+# RUN:                                  & !SHF_MERGE)  *(.sec.* *.text) }\
+# RUN: } " > %t5.script
+
+# RUN: ld.lld -o %t5 --script %t5.script %t.o
+# RUN: llvm-readobj --symbols %t5 | FileCheck --check-prefix MULTIPLE %s
+
+# MULTIPLE:  Name: _start
+# MULTIPLE:  Section: .outsec1
+# MULTIPLE:  Name: s1
+# MULTIPLE:  Section: .outsec1
+# MULTIPLE:  Name: s2
+# MULTIPLE:  Section: .outsec1
+# MULTIPLE:  Name: s3
+# MULTIPLE:  Section: .sec.aw
+# MULTIPLE:  Name: s4
+# MULTIPLE:  Section: .sec.aM
+# MULTIPLE:  Name: s5
+# MULTIPLE:  Section: .sec.aMS
+
+ .text
+ .global _start
+_start:
+ nop
+
+ .section .sec.a, "a", @progbits
+ .globl s1
+s1:
+ .long 1
+
+ .section .sec.ax, "ax", @progbits
+ .globl s2
+s2:
+ .long 2
+
+ .section .sec.aw, "aw", @progbits
+ .globl s3
+s3:
+ .long 3
+
+ .section .sec.aM, "aM", @progbits, 4
+ .globl s4
+s4:
+ .long 4
+
+ .section .sec.aMS, "aMS", @progbits, 1
+ .globl s5
+s5:
+ .asciz "a"