Support `#pragma clang section` directives on MachO targets

[jroelofs]

llvm/test/CodeGen/AArch64/clang-section-macho.ll

8

"__TEXT,__mytext"

[aaron.ballman]

FWIW, the attribute bits look reasonable to me.

clang/lib/Sema/SemaDeclAttr.cpp

3056–3058

Might as well fix the formatting issues.

[jroelofs]

git clang-format

[t.p.northover]

clang/lib/Sema/SemaAttr.cpp

304

Shouldn't this block return so the section doesn't get marked as valid later?

[jroelofs]

clang/lib/Sema/SemaAttr.cpp

304

yes!

[jroelofs]

Mark section invalid if the target doesn't like how it's spelled.

[t.p.northover]

Thanks. I think it looks good too now.

clang/include/clang/Basic/DiagnosticSemaKinds.td

   "alignment (%0) of thread-local variable %1 is greater than the maximum supported "
   "alignment (%2) for a thread-local variable on this target">;
 
 def err_only_annotate_after_access_spec : Error<
   "access specifier can only have annotation attributes">;
 
 def err_attribute_section_invalid_for_target : Error<
   "argument to %select{'code_seg'|'section'}1 attribute is not valid for this target: %0">;
+def err_pragma_section_invalid_for_target : Error<
+  "argument to #pragma section is not valid for this target: %0">;
 def warn_attribute_section_drectve : Warning<
   "#pragma %0(\".drectve\") has undefined behavior, "
   "use #pragma comment(linker, ...) instead">, InGroup<MicrosoftDrectveSection>;
 def warn_mismatched_section : Warning<
   "%select{codeseg|section}0 does not match previous declaration">, InGroup<Section>;
 def warn_attribute_section_on_redeclaration : Warning<
   "section attribute is specified on redeclared variable">, InGroup<Section>;
 def err_mismatched_code_seg_base : Error<

clang/include/clang/Basic/TargetInfo.h

 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Frontend/OpenMP/OMPGridValues.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/VersionTuple.h"
 #include <cassert>
 #include <string>
 #include <vector>
 
 namespace llvm {
 struct fltSemantics;
 class DataLayout;
virtual bool shouldDLLImportComdatSymbols() const {
     return getTriple().isWindowsMSVCEnvironment() ||
            getTriple().isWindowsItaniumEnvironment() || getTriple().isPS4CPU();
   }
 
   /// An optional hook that targets can implement to perform semantic
   /// checking on attribute((section("foo"))) specifiers.
   ///
   /// In this case, "foo" is passed in to be checked.  If the section
-  /// specifier is invalid, the backend should return a non-empty string
-  /// that indicates the problem.
+  /// specifier is invalid, the backend should return an Error that indicates
+  /// the problem.
   ///
   /// This hook is a simple quality of implementation feature to catch errors
   /// and give good diagnostics in cases when the assembler or code generator
   /// would otherwise reject the section specifier.
   ///
-  virtual std::string isValidSectionSpecifier(StringRef SR) const {
-    return "";
+  virtual llvm::Error isValidSectionSpecifier(StringRef SR) const {
+    return llvm::Error::success();
   }
 
   /// Set forced language options.
   ///
   /// Apply changes to the target information with respect to certain
   /// language options which change the target configuration and adjust
   /// the language based on the target options where applicable.
   virtual void adjust(LangOptions &Opts);

clang/lib/Basic/Targets/OSTargets.h

else if (Triple.isiOS()) {
         this->TLSSupported = !Triple.isOSVersionLT(2);
       else
         this->TLSSupported = !Triple.isOSVersionLT(3);
     }
 
     this->MCountName = "\01mcount";
   }
 
-  std::string isValidSectionSpecifier(StringRef SR) const override {
+  llvm::Error isValidSectionSpecifier(StringRef SR) const override {
     // Let MCSectionMachO validate this.
     StringRef Segment, Section;
     unsigned TAA, StubSize;
     bool HasTAA;
     return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
                                                        TAA, HasTAA, StubSize);
   }
 

clang/lib/Sema/SemaAttr.cpp

default:
       llvm_unreachable("invalid clang section kind");
   }
 
   if (Action == PragmaClangSectionAction::PCSA_Clear) {
     CSec->Valid = false;
     return;
   }
 
+  if (llvm::Error E = Context.getTargetInfo().isValidSectionSpecifier(SecName))
+    Diag(PragmaLoc, diag::err_pragma_section_invalid_for_target)
+        << toString(std::move(E));
+
   if (UnifySection(SecName, SectionFlags, PragmaLoc))
     return;
 
   CSec->Valid = true;
   CSec->SectionName = std::string(SecName);
   CSec->PragmaLocation = PragmaLoc;
 }
 

clang/lib/Sema/SemaDeclAttr.cpp

 #include "clang/Sema/ParsedAttr.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/Assumptions.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace sema;
 
 namespace AttributeLangSupport {
   enum LANG {

          << 1 /*section*/;
     Diag(CI.getLoc(), diag::note_previous_attribute);
     return nullptr;
   }
   return ::new (Context) SectionAttr(Context, CI, Name);
 }
 
 bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) {
-  std::string Error = Context.getTargetInfo().isValidSectionSpecifier(SecName);
-  if (!Error.empty()) {
-    Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error
+  if (llvm::Error E = Context.getTargetInfo().isValidSectionSpecifier(SecName)) {
+    Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
+         << toString(std::move(E))
          << 1 /*'section'*/;
     return false;
   }
   return true;
 }
 
 static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   // Make sure that there is a string literal as the sections's single
   // argument.
   StringRef Str;
   SourceLocation LiteralLoc;
   if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
     return;
 
   if (!S.checkSectionName(LiteralLoc, Str))
     return;
 
   // If the target wants to validate the section specifier, make it happen.
-  std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(Str);
-  if (!Error.empty()) {
+  if (llvm::Error E = S.Context.getTargetInfo().isValidSectionSpecifier(Str)) {
     S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
-    << Error;
+        << toString(std::move(E));
     return;
   }
 
   SectionAttr *NewAttr = S.mergeSectionAttr(D, AL, Str);
   if (NewAttr) {
     D->addAttr(NewAttr);
     if (isa<FunctionDecl, FunctionTemplateDecl, ObjCMethodDecl,
             ObjCPropertyDecl>(D))
       S.UnifySection(NewAttr->getName(),
                      ASTContext::PSF_Execute | ASTContext::PSF_Read,
                      cast<NamedDecl>(D));
   }
 }
 
 // This is used for `__declspec(code_seg("segname"))` on a decl.
 // `#pragma code_seg("segname")` uses checkSectionName() instead.
 static bool checkCodeSegName(Sema &S, SourceLocation LiteralLoc,
                              StringRef CodeSegName) {
-  std::string Error =
-      S.Context.getTargetInfo().isValidSectionSpecifier(CodeSegName);
-  if (!Error.empty()) {
+  if (llvm::Error E = S.Context.getTargetInfo().isValidSectionSpecifier(CodeSegName)) {
     S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
-        << Error << 0 /*'code-seg'*/;
+        << toString(std::move(E)) << 0 /*'code-seg'*/;
     return false;
   }
 
   return true;
 }
 
 CodeSegAttr *Sema::mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI,
                                     StringRef Name) {

clang/test/CodeGenCXX/clang-sections.cpp

-// RUN: %clang_cc1 -emit-llvm -triple arm-none-eabi -o - %s | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -triple arm-none-eabi -o - %s | FileCheck %s --check-prefixes=CHECK,ELF
+// RUN: %clang_cc1 -emit-llvm -triple arm64-apple-ios -o - %s | FileCheck %s --check-prefixes=CHECK,MACHO
 // Test that global variables, statics and functions are attached section-attributes
 // as per '#pragma clang section' directives.
 
 extern "C" {
 // test with names for each section
+#ifdef __MACH__
+#pragma clang section bss="__BSS,__mybss1" data="__DATA,__mydata1" rodata="__RODATA,__myrodata1"
+#pragma clang section text="__TEXT,__mytext1"
+#else
 #pragma clang section bss="my_bss.1" data="my_data.1" rodata="my_rodata.1"
 #pragma clang section text="my_text.1"
+#endif
 int a;      // my_bss.1
 int b = 1;  // my_data.1
 int c[4];   // my_bss.1
 short d[5] = {0}; // my_bss.1
 short e[6] = {0, 0, 1}; // my_data.1
 extern const int f;
 const int f = 2;  // my_rodata.1
 int foo(void) {   // my_text.1
   return b;
 }
 static int g[2]; // my_bss.1
 #pragma clang section bss=""
 int h; // default - .bss
+#ifdef __MACH__
+#pragma clang section data=""  bss="__BSS,__mybss2" text="__TEXT,__mytext2"
+#else
 #pragma clang section data=""  bss="my_bss.2" text="my_text.2"
+#endif
 int i = 0; // my_bss.2
 extern const int j;
 const int j = 4; // default - .rodata
 int k; // my_bss.2
 extern int zoo(int *x, int *y);
 int goo(void) {  // my_text.2
   static int lstat_h;  // my_bss.2
   return zoo(g, &lstat_h);
 }
+#ifdef __MACH__
+#pragma clang section rodata="__RODATA,__myrodata2" data="__DATA,__mydata2" relro="__RELRO,__myrelro2"
+#else
 #pragma clang section rodata="my_rodata.2" data="my_data.2" relro="my_relro.2"
+#endif
 int l = 5; // my_data.2
 extern const int m;
 const int m = 6; // my_rodata.2
 
 typedef int (*fptr_t)(void);
 const fptr_t fptrs[2] = {&foo, &goo};
 #pragma clang section rodata="" data="" bss="" text=""
 int n; // default

 //CHECK: @_ZL1g = internal global [2 x i32] zeroinitializer, align 4 #0
 
 //CHECK: @l ={{.*}} global i32 5, align 4 #3
 //CHECK: @m ={{.*}} constant i32 6, align 4 #3
 
 //CHECK: @n ={{.*}} global i32 0, align 4
 //CHECK: @o ={{.*}} global i32 6, align 4
 //CHECK: @p ={{.*}} constant i32 7, align 4
-//CHECK: @_ZL5fptrs = internal constant [2 x i32 ()*] [i32 ()* @foo, i32 ()* @goo], align 4 #3
+//CHECK: @_ZL5fptrs = internal constant [2 x i32 ()*] [i32 ()* @foo, i32 ()* @goo], align {{4|8}} #3
 
 //CHECK: define{{.*}} i32 @foo() #5 {
 //CHECK: define{{.*}} i32 @goo() #6 {
 //CHECK: declare i32 @zoo(i32*, i32*) #7
 //CHECK: define{{.*}} i32 @hoo() #8 {
 
-//CHECK: attributes #0 = { "bss-section"="my_bss.1" "data-section"="my_data.1" "rodata-section"="my_rodata.1" }
-//CHECK: attributes #1 = { "data-section"="my_data.1" "rodata-section"="my_rodata.1" }
-//CHECK: attributes #2 = { "bss-section"="my_bss.2" "rodata-section"="my_rodata.1" }
-//CHECK: attributes #3 = { "bss-section"="my_bss.2" "data-section"="my_data.2" "relro-section"="my_relro.2" "rodata-section"="my_rodata.2" }
-//CHECK: attributes #4 = { "relro-section"="my_relro.2" }
-//CHECK: attributes #5 = { {{.*"implicit-section-name"="my_text.1".*}} }
-//CHECK: attributes #6 = { {{.*"implicit-section-name"="my_text.2".*}} }
+//ELF: attributes #0 = { "bss-section"="my_bss.1" "data-section"="my_data.1" "rodata-section"="my_rodata.1" }
+//ELF: attributes #1 = { "data-section"="my_data.1" "rodata-section"="my_rodata.1" }
+//ELF: attributes #2 = { "bss-section"="my_bss.2" "rodata-section"="my_rodata.1" }
+//ELF: attributes #3 = { "bss-section"="my_bss.2" "data-section"="my_data.2" "relro-section"="my_relro.2" "rodata-section"="my_rodata.2" }
+//ELF: attributes #4 = { "relro-section"="my_relro.2" }
+//ELF: attributes #5 = { {{.*"implicit-section-name"="my_text.1".*}} }
+//ELF: attributes #6 = { {{.*"implicit-section-name"="my_text.2".*}} }
+//MACHO: attributes #0 = { "bss-section"="__BSS,__mybss1" "data-section"="__DATA,__mydata1" "rodata-section"="__RODATA,__myrodata1" }
+//MACHO: attributes #1 = { "data-section"="__DATA,__mydata1" "rodata-section"="__RODATA,__myrodata1" }
+//MACHO: attributes #2 = { "bss-section"="__BSS,__mybss2" "rodata-section"="__RODATA,__myrodata1" }
+//MACHO: attributes #3 = { "bss-section"="__BSS,__mybss2" "data-section"="__DATA,__mydata2" "relro-section"="__RELRO,__myrelro2" "rodata-section"="__RODATA,__myrodata2" }
+//MACHO: attributes #4 = { "relro-section"="__RELRO,__myrelro2" }
+//MACHO: attributes #5 = { {{.*"implicit-section-name"="__TEXT,__mytext1".*}} }
+//MACHO: attributes #6 = { {{.*"implicit-section-name"="__TEXT,__mytext2".*}} }
 //CHECK-NOT: attributes #7 = { {{.*"implicit-section-name".*}} }
 //CHECK-NOT: attributes #8 = { {{.*"implicit-section-name".*}} }

clang/test/Sema/pragma-clang-section-macho.c

+// RUN: %clang_cc1 -fsyntax-only -verify %s -triple arm64-apple-ios
+
+#pragma clang section bss="" data="" rodata="" text=""
+#pragma clang section bss="" data="" rodata="" text="__TEXT,__text"
+#pragma clang section bss="" data="" rodata="" text="badname" // expected-error {{argument to #pragma section is not valid for this target: mach-o section specifier requires a segment and section separated by a comma}}
+#pragma clang section bss="" data="" rodata="" text="__TEXT,__namethatiswaytoolong" // expected-error {{argument to #pragma section is not valid for this target: mach-o section specifier requires a section whose length is between 1 and 16 characters}}
+#pragma clang section
+
+int a;

llvm/include/llvm/MC/MCSectionMachO.h

public:
   bool hasAttribute(unsigned Value) const {
     return (TypeAndAttributes & Value) != 0;
   }
 
   /// Parse the section specifier indicated by "Spec". This is a string that can
   /// appear after a .section directive in a mach-o flavored .s file.  If
   /// successful, this fills in the specified Out parameters and returns an
   /// empty string.  When an invalid section specifier is present, this returns
-  /// a string indicating the problem. If no TAA was parsed, TAA is not altered,
+  /// an Error indicating the problem. If no TAA was parsed, TAA is not altered,
   /// and TAAWasSet becomes false.
-  static std::string ParseSectionSpecifier(StringRef Spec,       // In.
-                                           StringRef &Segment,   // Out.
-                                           StringRef &Section,   // Out.
-                                           unsigned  &TAA,       // Out.
-                                           bool      &TAAParsed, // Out.
-                                           unsigned  &StubSize); // Out.
+  static Error ParseSectionSpecifier(StringRef Spec,       // In.
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
 
   static bool classof(const MCSection *S) {
     return S->getVariant() == SV_MachO;
   }
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 
   // The section is mandatory. If we don't have it, then we don't have GC info.
   if (SectionVal.empty())
     return;
 
   StringRef Segment, Section;
   unsigned TAA = 0, StubSize = 0;
   bool TAAParsed;
-  std::string ErrorCode =
-    MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
-                                          TAA, TAAParsed, StubSize);
-  if (!ErrorCode.empty())
+  if (Error E = MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment,
+                                                      Section, TAA, TAAParsed,
+                                                      StubSize)) {
     // If invalid, report the error with report_fatal_error.
     report_fatal_error("Invalid section specifier '" + Section + "': " +
-                       ErrorCode + ".");
+                       toString(std::move(E)) + ".");
+  }
 
   // Get the section.
   MCSectionMachO *S = getContext().getMachOSection(
       Segment, Section, TAA, StubSize, SectionKind::getData());
   Streamer.SwitchSection(S);
   Streamer.emitLabel(getContext().
                      getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
   Streamer.emitInt32(VersionVal);
   Streamer.emitInt32(ImageInfoFlags);
   Streamer.AddBlankLine();
 }
 
 static void checkMachOComdat(const GlobalValue *GV) {
   const Comdat *C = GV->getComdat();
   if (!C)
     return;
 
   report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
                      "' cannot be lowered.");
 }
 
 MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
+
+  StringRef SectionName = GO->getSection();
+
+  const Function *F = dyn_cast<Function>(GO);
+  if (F && F->hasFnAttribute("implicit-section-name")) {
+    SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
+  }
+
   // Parse the section specifier and create it if valid.
   StringRef Segment, Section;
   unsigned TAA = 0, StubSize = 0;
   bool TAAParsed;
 
   checkMachOComdat(GO);
 
-  std::string ErrorCode =
-    MCSectionMachO::ParseSectionSpecifier(GO->getSection(), Segment, Section,
-                                          TAA, TAAParsed, StubSize);
-  if (!ErrorCode.empty()) {
+  if (Error E = MCSectionMachO::ParseSectionSpecifier(SectionName, Segment,
+                                                      Section, TAA, TAAParsed,
+                                                      StubSize)) {
     // If invalid, report the error with report_fatal_error.
     report_fatal_error("Global variable '" + GO->getName() +
                        "' has an invalid section specifier '" +
-                       GO->getSection() + "': " + ErrorCode + ".");
+                       GO->getSection() + "': " + toString(std::move(E)) + ".");
   }
 
   // Get the section.
   MCSectionMachO *S =
       getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
 
   // If TAA wasn't set by ParseSectionSpecifier() above,
   // use the value returned by getMachOSection() as a default.

llvm/lib/MC/MCParser/DarwinAsmParser.cpp

 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/SectionKind.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
bool DarwinAsmParser::parseDirectiveSection(StringRef, SMLoc) {
   if (getLexer().isNot(AsmToken::EndOfStatement))
     return TokError("unexpected token in '.section' directive");
   Lex();
 
   StringRef Segment, Section;
   unsigned StubSize;
   unsigned TAA;
   bool TAAParsed;
-  std::string ErrorStr =
-    MCSectionMachO::ParseSectionSpecifier(SectionSpec, Segment, Section,
-                                          TAA, TAAParsed, StubSize);
-
-  if (!ErrorStr.empty())
-    return Error(Loc, ErrorStr);
+  if (class Error E = MCSectionMachO::ParseSectionSpecifier(SectionSpec, Segment,
+                                                            Section, TAA, TAAParsed,
+                                                            StubSize))
+    return Error(Loc, toString(std::move(E)));
 
   // Issue a warning if the target is not powerpc and Section is a *coal* section.
   Triple TT = getParser().getContext().getObjectFileInfo()->getTargetTriple();
   Triple::ArchType ArchTy = TT.getArch();
 
   if (ArchTy != Triple::ppc && ArchTy != Triple::ppc64) {
     StringRef NonCoalSection = StringSwitch<StringRef>(Section)
                                    .Case("__textcoal_nt", "__text")

llvm/lib/MC/MCSectionMachO.cpp

return (getType() == MachO::S_ZEROFILL ||
           getType() == MachO::S_THREAD_LOCAL_ZEROFILL);
 }
 
 /// ParseSectionSpecifier - Parse the section specifier indicated by "Spec".
 /// This is a string that can appear after a .section directive in a mach-o
 /// flavored .s file.  If successful, this fills in the specified Out
 /// parameters and returns an empty string.  When an invalid section
 /// specifier is present, this returns a string indicating the problem.
-std::string MCSectionMachO::ParseSectionSpecifier(StringRef Spec,        // In.
-                                                  StringRef &Segment,    // Out.
-                                                  StringRef &Section,    // Out.
-                                                  unsigned  &TAA,        // Out.
-                                                  bool      &TAAParsed,  // Out.
-                                                  unsigned  &StubSize) { // Out.
+Error MCSectionMachO::ParseSectionSpecifier(StringRef Spec,        // In.
   TAAParsed = false;
 
   SmallVector<StringRef, 5> SplitSpec;
   Spec.split(SplitSpec, ',');
   // Remove leading and trailing whitespace.
   auto GetEmptyOrTrim = [&SplitSpec](size_t Idx) -> StringRef {
     return SplitSpec.size() > Idx ? SplitSpec[Idx].trim() : StringRef();
   };
   Segment = GetEmptyOrTrim(0);
   Section = GetEmptyOrTrim(1);
   StringRef SectionType = GetEmptyOrTrim(2);
   StringRef Attrs = GetEmptyOrTrim(3);
   StringRef StubSizeStr = GetEmptyOrTrim(4);
 
-  // Verify that the segment is present and not too long.
-  if (Segment.empty() || Segment.size() > 16)
-    return "mach-o section specifier requires a segment whose length is "
-           "between 1 and 16 characters";
-
-  // Verify that the section is present and not too long.
+  // Verify that the section is present.
   if (Section.empty())
-    return "mach-o section specifier requires a segment and section "
-           "separated by a comma";
+    return createStringError(inconvertibleErrorCode(),
+                             "mach-o section specifier requires a segment "
+                             "and section separated by a comma");
 
+  // Verify that the section is not too long.
   if (Section.size() > 16)
-    return "mach-o section specifier requires a section whose length is "
-           "between 1 and 16 characters";
+    return createStringError(inconvertibleErrorCode(),
+                             "mach-o section specifier requires a section "
+                             "whose length is between 1 and 16 characters");
 
   // If there is no comma after the section, we're done.
   TAA = 0;
   StubSize = 0;
   if (SectionType.empty())
-    return "";
+    return Error::success();
 
   // Figure out which section type it is.
   auto TypeDescriptor =
       llvm::find_if(SectionTypeDescriptors,
                     [&](decltype(*SectionTypeDescriptors) &Descriptor) {
                       return SectionType == Descriptor.AssemblerName;
                     });
 
   // If we didn't find the section type, reject it.
   if (TypeDescriptor == std::end(SectionTypeDescriptors))
-    return "mach-o section specifier uses an unknown section type";
+    return createStringError(inconvertibleErrorCode(),
+                             "mach-o section specifier uses an unknown "
+                             "section type");
 
   // Remember the TypeID.
   TAA = TypeDescriptor - std::begin(SectionTypeDescriptors);
   TAAParsed = true;
 
   // If we have no comma after the section type, there are no attributes.
   if (Attrs.empty()) {
     // S_SYMBOL_STUBS always require a symbol stub size specifier.
     if (TAA == MachO::S_SYMBOL_STUBS)
-      return "mach-o section specifier of type 'symbol_stubs' requires a size "
-             "specifier";
-    return "";
+      return createStringError(inconvertibleErrorCode(),
+                               "mach-o section specifier of type "
+                               "'symbol_stubs' requires a size specifier");
+    return Error::success();
   }
 
   // The attribute list is a '+' separated list of attributes.
   SmallVector<StringRef, 1> SectionAttrs;
   Attrs.split(SectionAttrs, '+', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
 
   for (StringRef &SectionAttr : SectionAttrs) {
     auto AttrDescriptorI =
         llvm::find_if(SectionAttrDescriptors,
                       [&](decltype(*SectionAttrDescriptors) &Descriptor) {
                         return SectionAttr.trim() == Descriptor.AssemblerName;
                       });
     if (AttrDescriptorI == std::end(SectionAttrDescriptors))
-      return "mach-o section specifier has invalid attribute";
+      return createStringError(inconvertibleErrorCode(),
+                               "mach-o section specifier has invalid "
+                               "attribute");
 
     TAA |= AttrDescriptorI->AttrFlag;
   }
 
   // Okay, we've parsed the section attributes, see if we have a stub size spec.
   if (StubSizeStr.empty()) {
     // S_SYMBOL_STUBS always require a symbol stub size specifier.
     if (TAA == MachO::S_SYMBOL_STUBS)
-      return "mach-o section specifier of type 'symbol_stubs' requires a size "
-      "specifier";
-    return "";
+      return createStringError(inconvertibleErrorCode(),
+                               "mach-o section specifier of type "
+                               "'symbol_stubs' requires a size specifier");
+    return Error::success();
   }
 
   // If we have a stub size spec, we must have a sectiontype of S_SYMBOL_STUBS.
   if ((TAA & MachO::SECTION_TYPE) != MachO::S_SYMBOL_STUBS)
-    return "mach-o section specifier cannot have a stub size specified because "
-           "it does not have type 'symbol_stubs'";
+    return createStringError(inconvertibleErrorCode(),
+                             "mach-o section specifier cannot have a stub "
+                             "size specified because it does not have type "
+                             "'symbol_stubs'");
 
   // Convert the stub size from a string to an integer.
   if (StubSizeStr.getAsInteger(0, StubSize))
-    return "mach-o section specifier has a malformed stub size";
+    return createStringError(inconvertibleErrorCode(),
+                             "mach-o section specifier has a malformed "
+                             "stub size");
 
-  return "";
+  return Error::success();
 }

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

                         << *G << "\n");
       return false;
     }
 
     if (TargetTriple.isOSBinFormatMachO()) {
       StringRef ParsedSegment, ParsedSection;
       unsigned TAA = 0, StubSize = 0;
       bool TAAParsed;
-      std::string ErrorCode = MCSectionMachO::ParseSectionSpecifier(
-          Section, ParsedSegment, ParsedSection, TAA, TAAParsed, StubSize);
-      assert(ErrorCode.empty() && "Invalid section specifier.");
+      cantFail(MCSectionMachO::ParseSectionSpecifier(Section,
+                                                     ParsedSegment,
+                                                     ParsedSection,
+                                                     TAA, TAAParsed,
+                                                     StubSize));
 
       // Ignore the globals from the __OBJC section. The ObjC runtime assumes
       // those conform to /usr/lib/objc/runtime.h, so we can't add redzones to
       // them.
       if (ParsedSegment == "__OBJC" ||
           (ParsedSegment == "__DATA" && ParsedSection.startswith("__objc_"))) {
         LLVM_DEBUG(dbgs() << "Ignoring ObjC runtime global: " << *G << "\n");
         return false;

llvm/test/CodeGen/AArch64/clang-section-macho.ll

+;RUN: llc -mtriple=arm64-apple-ios %s -o - | FileCheck %s
+
+define dso_local void @foo() #0 {
+entry:
+  ret void
+}
+
+attributes #0 = { "implicit-section-name"="TEXT,mytext" }
+
+; CHECK:      .section  TEXT,mytext
+; CHECK-NEXT: .globl  _foo