[lld-macho] Add isCodeSection()

[int3]

Summary

This is the same logic that ld64 uses to determine which sections
contain functions. This was added so that we could determine which
STABS entries should be N_FUN.

[clayborg]

lld/MachO/InputSection.cpp

67

BTW there is also a S_ATTR_SOME_INSTRUCTIONS attribute we might be able to use and improve.

[int3]

lld/MachO/InputSection.cpp

67

hmm I don't think ld64 uses S_ATTR_SOME_INSTRUCTIONS to identify code sections. (Though it does ensure that every code section it emits has both S_ATTR_SOME_INSTRUCTIONS and S_ATTR_PURE_INSTRUCTIONS set.)

[smeenai]

lld/MachO/InputSection.cpp

67

Out of curiosity, how does S_ATTR_PURE_INSTRUCTIONS interact with LC_DATA_IN_CODE? For example, if Clang ends up emitting an ARM constant pool into the text section (so it's not technically pure instructions), is the section still marked as pure instructions?

[smeenai]

lld/MachO/InputSection.cpp

67

To answer my own question, I'm having a hard time getting clang to produce a constant pool for arm64, but at least for armv7, it marks __TEXT,__text as pure instructions despite the constant pool: https://godbolt.org/z/MaT9E1

[int3]

lld/MachO/InputSection.cpp

67

thanks for checking that case :)

lld/MachO/InputSection.h

public:
 
   uint32_t align = 1;
   uint32_t flags = 0;
 
   ArrayRef<uint8_t> data;
   std::vector<Reloc> relocs;
 };
 
+bool isCodeSection(InputSection *);
+
 extern std::vector<InputSection *> inputSections;
 
 } // namespace macho
 
 std::string toString(const macho::InputSection *);
 
 } // namespace lld
 
 #endif

lld/MachO/InputSection.cpp

for (Reloc &r : relocs) {
 
     uint64_t referentVal = referentVA + r.addend;
     if (r.pcrel)
       referentVal -= getVA() + r.offset;
     target->relocateOne(buf + r.offset, r, referentVal);
   }
 }
 
+bool macho::isCodeSection(InputSection *isec) {
+  uint32_t type = isec->flags & MachO::SECTION_TYPE;
+  if (type != S_REGULAR && type != S_COALESCED)
+    return false;
+
+  uint32_t attr = isec->flags & MachO::SECTION_ATTRIBUTES_USR;
+  if (attr == S_ATTR_PURE_INSTRUCTIONS)
+    return true;
+
+  if (isec->segname == segment_names::text)
+    return StringSwitch<bool>(isec->name)
+        .Cases("__textcoal_nt", "__StaticInit", true)
+        .Default(false);
+
+  return false;
+}
+
 std::string lld::toString(const InputSection *isec) {
   return (toString(isec->file) + ":(" + isec->name + ")").str();
 }

lld/MachO/SyntheticSections.cpp

if (lastFile == nullptr || lastFile != file) {
       emitObjectFileStab(file);
     }
 
     StabsEntry symStab;
     symStab.sect = defined->isec->parent->index;
     symStab.strx = stringTableSection.addString(defined->getName());
     symStab.value = defined->getVA();
 
-    // XXX is it right to assume that all symbols in __text are function
-    // symbols?
-    if (isec->name == "__text") {
+    if (isCodeSection(isec)) {
       symStab.type = MachO::N_FUN;
       stabs.emplace_back(std::move(symStab));
       emitEndFunStab(defined);
     } else {
       symStab.type = defined->isExternal() ? MachO::N_GSYM : MachO::N_STSYM;
       stabs.emplace_back(std::move(symStab));
     }
   }

lld/test/MachO/stabs.s

 # RUN:   FileCheck %s -DDIR=%t -DFOO_PATH=%t/foo.a\(foo.o\)
 
 # CHECK:       Sections:
 # CHECK-NEXT:  Idx                Name
 # CHECK-NEXT:  [[#TEXT_ID:]]      __text
 # CHECK-NEXT:  [[#DATA_ID:]]      __data
 # CHECK-NEXT:  [[#MORE_DATA_ID:]] more_data
 # CHECK-NEXT:  [[#COMM_ID:]]      __common
+# CHECK-NEXT:  [[#MORE_TEXT_ID:]] more_text
 
 # CHECK:       0000000000000000 - 00                     0000    SO /tmp/test.cpp
 # CHECK-NEXT:  0000000000000010 - 03                     0001   OSO [[DIR]]/test.o
 # CHECK-NEXT:  [[#%x, STATIC:]] - 0[[#MORE_DATA_ID + 1]] 0000 STSYM _static_var
 # CHECK-NEXT:  [[#%x, MAIN:]]   - 0[[#TEXT_ID + 1]]      0000   FUN _main
 # CHECK-NEXT:  0000000000000006 - 00                     0000   FUN
+# CHECK-NEXT:  [[#%x, FUN:]]    - 0[[#MORE_TEXT_ID + 1]] 0000   FUN _fun
+# CHECK-NEXT:  0000000000000001 - 00                     0000   FUN
 # CHECK-NEXT:  [[#%x, GLOB:]]   - 0[[#DATA_ID + 1]]      0000  GSYM _global_var
 # CHECK-NEXT:  [[#%x, ZERO:]]   - 0[[#COMM_ID + 1]]      0000  GSYM _zero
 # CHECK-NEXT:  0000000000000000 - 01                     0000    SO
 # CHECK-NEXT:  0000000000000000 - 00                     0000    SO /foo.cpp
 # CHECK-NEXT:  0000000000000020 - 03                     0001   OSO [[FOO_PATH]]
 # CHECK-NEXT:  [[#%x, FOO:]]    - 0[[#TEXT_ID + 1]]      0000   FUN _foo
 # CHECK-NEXT:  0000000000000001 - 00                     0000   FUN
 # CHECK-NEXT:  0000000000000000 - 01                     0000    SO
 # CHECK-NEXT:  [[#STATIC]]      s _static_var
 # CHECK-NEXT:  [[#MAIN]]        T _main
 # CHECK-NEXT:  {{[0-9af]+}}     A _abs
+# CHECK-NEXT:  [[#FUN]]         S _fun
 # CHECK-NEXT:  [[#GLOB]]        D _global_var
 # CHECK-NEXT:  [[#ZERO]]        S _zero
 # CHECK-NEXT:  [[#FOO]]         T _foo
 # CHECK-NEXT:  {{[0-9af]+}}     T _no_debug
 # CHECK-EMPTY:
 
 #--- test.s
 
.set Lset1, Lsection_abbrev-Lsection_abbrev ## Offset Into Abbrev. Section
   .quad  Lfunc_begin0            ## DW_AT_low_pc
 .set Lset3, Lfunc_end0-Lfunc_begin0     ## DW_AT_high_pc
   .long  Lset3
   .byte  0                       ## End Of Children Mark
 Ldebug_info_end0:
 .subsections_via_symbols
 .section  __DWARF,__debug_line,regular,debug
 
+.section OTHER,more_text,regular,pure_instructions
+.globl _fun
+_fun:
+  ret
+
 #--- foo.s
 .text
 .globl  _foo
 _foo:
 Lfunc_begin0:
   retq
 Lfunc_end0: