Mark the $local function begin symbol as a function

[arichardson]

Summary

While this does not matter for most targets, when building for Arm Morello,
we have to mark the symbol as a function and add size information, so that
LLD can correctly evaluate relocations against the local symbol.
Since Morello is an out-of-tree target, I tried to reproduce this with
in-tree backends and with the previous reviews applied this results in
a noticeable difference when targeting Thumb.

Background: Morello uses a method similar Thumb where the encoding mode is
specified in the LSB of the symbol. If we don't mark the target as a
function, the relocation will not have the LSB set and calls will end up
using the wrong encoding mode (which will almost certainly crash).

[arichardson]

• rebase
• fix update_llc_test_checks for Arm as well

[arichardson]

ping?

[MaskRay]

(I am out of town.)

[arichardson]

Rebase after D131433 was reverted

llvm/include/llvm/CodeGen/AsmPrinter.h

private:
   /// Output stream for the stack usage file (i.e., .su file).
   std::unique_ptr<raw_fd_ostream> StackUsageStream;
 
   static char ID;
 
 protected:
   MCSymbol *CurrentFnBegin = nullptr;
 
+  /// For dso_local functions, the current $local alias for the function.
+  MCSymbol *CurrentFnBeginLocal = nullptr;
+
   /// A vector of all debug/EH info emitters we should use. This vector
   /// maintains ownership of the emitters.
   std::vector<HandlerInfo> Handlers;
   size_t NumUserHandlers = 0;
 
 private:
   /// If generated on the fly this own the instance.
   std::unique_ptr<MachineDominatorTree> OwnedMDT;

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

void AsmPrinter::emitFunctionEntryLabel() {
   if (CurrentFnSym->isVariable())
     report_fatal_error("'" + Twine(CurrentFnSym->getName()) +
                        "' is a protected alias");
 
   OutStreamer->emitLabel(CurrentFnSym);
 
   if (TM.getTargetTriple().isOSBinFormatELF()) {
     MCSymbol *Sym = getSymbolPreferLocal(MF->getFunction());
-    if (Sym != CurrentFnSym)
+    if (Sym != CurrentFnSym) {
+      cast<MCSymbolELF>(Sym)->setType(ELF::STT_FUNC);
+      CurrentFnBeginLocal = Sym;
       OutStreamer->emitLabel(Sym);
+      if (MAI->hasDotTypeDotSizeDirective())
+        OutStreamer->emitSymbolAttribute(Sym, MCSA_ELF_TypeFunction);
+    }
   }
 }
 
 /// emitComments - Pretty-print comments for instructions.
 static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS) {
   const MachineFunction *MF = MI.getMF();
   const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
 
void AsmPrinter::emitFunctionBody() {
   // it.
   if (MAI->hasDotTypeDotSizeDirective()) {
     // We can get the size as difference between the function label and the
     // temp label.
     const MCExpr *SizeExp = MCBinaryExpr::createSub(
         MCSymbolRefExpr::create(CurrentFnEnd, OutContext),
         MCSymbolRefExpr::create(CurrentFnSymForSize, OutContext), OutContext);
     OutStreamer->emitELFSize(CurrentFnSym, SizeExp);
+    if (CurrentFnBeginLocal)
+      OutStreamer->emitELFSize(CurrentFnBeginLocal, SizeExp);
   }
 
   for (const HandlerInfo &HI : Handlers) {
     NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
                        HI.TimerGroupDescription, TimePassesIsEnabled);
     HI.Handler->markFunctionEnd();
   }
 
assert(CurrentFnDescSym && "The function descriptor symbol needs to be"
                                " initalized first.");
 
     // Get the function entry point symbol.
     CurrentFnSym = getObjFileLowering().getFunctionEntryPointSymbol(&F, TM);
   }
 
   CurrentFnSymForSize = CurrentFnSym;
   CurrentFnBegin = nullptr;
+  CurrentFnBeginLocal = nullptr;
   CurrentSectionBeginSym = nullptr;
   MBBSectionRanges.clear();
   MBBSectionExceptionSyms.clear();
   bool NeedsLocalForSize = MAI->needsLocalForSize();
   if (F.hasFnAttribute("patchable-function-entry") ||
       F.hasFnAttribute("function-instrument") ||
       F.hasFnAttribute("xray-instruction-threshold") ||
       needFuncLabelsForEHOrDebugInfo(MF) || NeedsLocalForSize ||

llvm/test/CodeGen/AArch64/elf-preemption.ll

 ; STATIC-LABEL: dsolocal_func:
 ; STATIC:       // %bb.0:
 ; STATIC-NEXT:    adrp x0, dsolocal_func
 ; STATIC-NEXT:    add x0, x0, :lo12:dsolocal_func
 ; STATIC-NEXT:    ret
 ;
 ; PIC-LABEL: dsolocal_func:
 ; PIC:       .Ldsolocal_func$local:
+; PIC-NEXT:    .type .Ldsolocal_func$local,@function
 ; PIC-NEXT:  // %bb.0:
 ; PIC-NEXT:    adrp x0, .Ldsolocal_func$local
 ; PIC-NEXT:    add x0, x0, :lo12:.Ldsolocal_func$local
 ; PIC-NEXT:    ret
   ret void()* bitcast(void()*()* @dsolocal_func to void()*)
 }
+; UTC-ARGS: --disable
+; PIC: [[END_LABEL:.Lfunc_end.+]]:
+; PIC-NEXT: .size dsolocal_func, [[END_LABEL]]-dsolocal_func
+; PIC-NEXT: .size .Ldsolocal_func$local, [[END_LABEL]]-dsolocal_func
+; UTC-ARGS: --enable
 
 define weak dso_local void()* @weak_dsolocal_func() nounwind {
 ; CHECK-LABEL: weak_dsolocal_func:
 ; CHECK:       // %bb.0:
 ; CHECK-NEXT:    adrp x0, weak_dsolocal_func
 ; CHECK-NEXT:    add x0, x0, :lo12:weak_dsolocal_func
 ; CHECK-NEXT:    ret
   ret void()* bitcast(void()*()* @weak_dsolocal_func to void()*)
 }
 
 ;; bl .Ldsolocal_func$local either resolves to a constant at assembly time
 ;; or produces a relocation which can potentially cause a veneer.
 define dso_local void @call_dsolocal_func() nounwind {
 ; STATIC-LABEL: call_dsolocal_func:
 ; STATIC:       // %bb.0:
 ; STATIC-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; STATIC-NEXT:    bl dsolocal_func
 ; STATIC-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; STATIC-NEXT:    ret
 ;
 ; PIC-LABEL: call_dsolocal_func:
 ; PIC:       .Lcall_dsolocal_func$local:
+; PIC-NEXT:    .type .Lcall_dsolocal_func$local,@function
 ; PIC-NEXT:  // %bb.0:
 ; PIC-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; PIC-NEXT:    bl .Ldsolocal_func$local
 ; PIC-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; PIC-NEXT:    ret
   call void()* @dsolocal_func()
   ret void
 }
+; UTC-ARGS: --disable
+; PIC: [[END_LABEL:.Lfunc_end.+]]:
+; PIC-NEXT: .size call_dsolocal_func, [[END_LABEL]]-call_dsolocal_func
+; PIC-NEXT: .size .Lcall_dsolocal_func$local, [[END_LABEL]]-call_dsolocal_func
+; UTC-ARGS: --enable

llvm/test/CodeGen/AArch64/semantic-interposition-asm.ll

 entry:
   %0 = tail call i64 asm "adrp $0, $1\0Aldr ${0:w}, [$0, :lo12:$1]\0Aadrp x8, $2\0Aldr w8, [x8, :lo12:$2]\0Aadd $0,x8,$0", "=r,S,S,~{x8}"(i32* nonnull @gv0, i32* nonnull @gv1)
   ret i64 %0
 }
 
 define dso_local void @fun0() nounwind {
 ; CHECK-LABEL: fun0:
 ; CHECK:       .Lfun0$local:
+; CHECK-NEXT:    .type .Lfun0$local,@function
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    ret
 entry:
   ret void
 }
 
 define dso_preemptable void @fun1() nounwind {
 ; CHECK-LABEL: fun1:

llvm/test/CodeGen/ARM/dso-local-func.ll

 ;; Check that we emit a $local alias for a dso_local function definition
 ; RUN: llc -mtriple=armv7-linux-gnueabi -relocation-model=static < %s \
 ; RUN:   | FileCheck %s --check-prefixes=CHECK,STATIC
 ; RUN: llc -mtriple=armv7-linux-gnueabi -relocation-model=pic < %s \
 ; RUN:   | FileCheck %s --check-prefixes=CHECK,PIC
 
 define dso_local ptr @dsolocal_func() nounwind {
 ; CHECK-LABEL:  .globl  dsolocal_func
 ; CHECK-NEXT:   .p2align  2
 ; CHECK-NEXT:   .type dsolocal_func,%function
 ; CHECK-NEXT:   .code 32
 ; CHECK-NEXT: dsolocal_func:
 ; PIC-NEXT: .Ldsolocal_func$local:
+; PIC-NEXT: .type .Ldsolocal_func$local,%function
 ; CHECK-NEXT:   .fnstart
 ; CHECK-NEXT: @ %bb.0:
 ; STATIC-NEXT:  movw  r0, :lower16:dsolocal_func
 ; STATIC-NEXT:  movt  r0, :upper16:dsolocal_func
 ; STATIC-NEXT:  bx  lr
 ; PIC-NEXT:     ldr r0, .LCPI0_0
 ; PIC-NEXT:   .LPC0_0:
 ; PIC-NEXT:     add r0, pc, r0
 ; PIC-NEXT:     bx  lr
 ; PIC-NEXT:     .p2align  2
 ; PIC-NEXT:   @ %bb.1:
 ; PIC-NEXT:   .LCPI0_0:
 ; PIC-NEXT:     .long dsolocal_func-(.LPC0_0+8)
 ; CHECK-NEXT: .Lfunc_end0:
 ; CHECK-NEXT:   .size dsolocal_func, .Lfunc_end0-dsolocal_func
+; PIC-NEXT:     .size .Ldsolocal_func$local, .Lfunc_end0-dsolocal_func
 ; CHECK-NEXT:   .cantunwind
 ; CHECK-NEXT:   .fnend
   ret ptr @dsolocal_func
 }

llvm/test/CodeGen/ARM/thumb-function-section-reloc.ll

 ; UTC-ARGS: --disable
 
 ; RELOCS-LABEL: Relocations [
 ; RELOCS-NEXT:   Section (5) .rel.ARM.exidx.text._ZdlPv {
 ; RELOCS-NEXT:     0x0 R_ARM_PREL31 .text._ZdlPv
 ; RELOCS-NEXT:   }
 ; RELOCS-NEXT:   Section (7) .rel.text.test {
 ; RELOCS-NEXT:     0x4 R_ARM_CALL _ZdlPv
-; FIXME: these two relocation should not be against the section!
-; RELOCS-NEXT:     0xC R_ARM_ABS32 .text._ZdlPv
-; RELOCS-NEXT:     0x10 R_ARM_ABS32 .text._ZdlPv
+; RELOCS-NEXT:     0xC R_ARM_ABS32 .L_ZdlPv$local
+; RELOCS-NEXT:     0x10 R_ARM_ABS32 .L_ZdlPv$local
 ; RELOCS-NEXT:     0x1C R_ARM_REL32 _ZdlPv
 ; RELOCS-NEXT:   }
 ; RELOCS-NEXT:   Section (9) .rel.ARM.exidx.text.test {
 ; RELOCS-NEXT:     0x0 R_ARM_PREL31 .text.test
 ; RELOCS-NEXT:   }
 ; RELOCS-NEXT:   Section (11) .rel.data {
 ; RELOCS-NEXT:     0x0 R_ARM_ABS32 _ZdlPv
 ; RELOCS-NEXT:   }
 ; RELOCS-NEXT: ]
 
 ; RELOCS-LABEL: Symbols [
-; RELOCS: Symbol {
-; FIXME: we should include the symbol in the symbol table!
-; RELOCS-NOT:    Name: .L_ZdlPv$local
-; RELOCS-TODO:   Name: .L_ZdlPv$local
-; RELOCS-TODO:   Value: 0x1
-; RELOCS-TODO:   Size: 2
-; RELOCS-TODO:   Binding: Local (0x0)
-; RELOCS-TODO:   Type: Function (0x2)
-; RELOCS-TODO:   Other: 0
-; RELOCS-TODO:   Section: .text._ZdlPv (
-; RELOCS-TODO: }
+; RELOCS:      Symbol {
+; RELOCS:        Name: .L_ZdlPv$local
+; RELOCS-NEXT:   Value: 0x1
+; RELOCS-NEXT:   Size: 2
+; RELOCS-NEXT:   Binding: Local (0x0)
+; RELOCS-NEXT:   Type: Function (0x2)
+; RELOCS-NEXT:   Other: 0
+; RELOCS-NEXT:   Section: .text._ZdlPv (
+; RELOCS-NEXT: }
 
 define dso_local void @_ZdlPv(ptr %ptr) local_unnamed_addr nounwind "target-features"="+armv7-a,+thumb-mode" {
 ; CHECK-LABEL:  .section  .text._ZdlPv,"ax",%progbits
 ; CHECK-NEXT:   .globl  _ZdlPv                          @ -- Begin function _ZdlPv
 ; CHECK-NEXT:   .p2align  1
 ; CHECK-NEXT:   .type _ZdlPv,%function
 ; CHECK-NEXT:   .code 16                              @ @_ZdlPv
 ; CHECK-NEXT:   .thumb_func
 ; CHECK-NEXT: _ZdlPv:
 ; CHECK-NEXT: .L_ZdlPv$local:
+; CHECK-NEXT: .type .L_ZdlPv$local,%function
 ; CHECK-NEXT:   .fnstart
 ; CHECK-NEXT: @ %bb.0:
 ; CHECK-NEXT:   bx  lr
 ; CHECK-NEXT: .Lfunc_end0:
 ; CHECK-NEXT:   .size _ZdlPv, .Lfunc_end0-_ZdlPv
+; CHECK-NEXT:   .size .L_ZdlPv$local, .Lfunc_end0-_ZdlPv
 ; CHECK-NEXT:   .cantunwind
 ; CHECK-NEXT:   .fnend
   ret void
 }
 
 define ptr @test(ptr %ptr) nounwind {
 ; CHECK-LABEL: test:
 ; CHECK:       @ %bb.0: @ %entry

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/amdgpu_generated_funcs.ll.generated.expected

define dso_local i32 @main() #0 {
   store i32 3, i32 addrspace(5)* %4, align 4
   store i32 4, i32 addrspace(5)* %5, align 4
   ret i32 0
 }
 
 attributes #0 = { noredzone nounwind ssp uwtable "frame-pointer"="all" }
 ; CHECK-LABEL: check_boundaries:
 ; CHECK:       check_boundaries$local:
+; CHECK-NEXT:    .type check_boundaries$local,@function
 ; CHECK-NEXT:  ; %bb.0:
 ; CHECK-NEXT:    s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
 ; CHECK-NEXT:    s_mov_b32 s4, s33
 ; CHECK-NEXT:    s_mov_b32 s33, s32
 ; CHECK-NEXT:    v_mov_b32_e32 v0, 0
 ; CHECK-NEXT:    s_mov_b32 s33, s4
 ; CHECK-NEXT:    s_setpc_b64 s[30:31]
 ;
 ; CHECK-LABEL: main:
 ; CHECK:       main$local:
+; CHECK-NEXT:    .type main$local,@function
 ; CHECK-NEXT:  ; %bb.0:
 ; CHECK-NEXT:    s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
 ; CHECK-NEXT:    s_mov_b32 s6, s33
 ; CHECK-NEXT:    s_mov_b32 s33, s32
 ; CHECK-NEXT:    s_getpc_b64 s[4:5]
 ; CHECK-NEXT:    s_add_u32 s4, s4, x@rel32@lo+4
 ; CHECK-NEXT:    s_addc_u32 s5, s5, x@rel32@hi+12
 ; CHECK-NEXT:    v_mov_b32_e32 v2, 1

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/amdgpu_generated_funcs.ll.nogenerated.expected

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -enable-machine-outliner -mtriple=amdgcn-adm-amdhsa < %s | FileCheck %s
 
 ; NOTE: Machine outliner doesn't run.
 @x = dso_local global i32 0, align 4
 
 define dso_local i32 @check_boundaries() #0 {
 ; CHECK-LABEL: check_boundaries:
 ; CHECK:       check_boundaries$local:
+; CHECK-NEXT:    .type check_boundaries$local,@function
 ; CHECK-NEXT:  ; %bb.0:
 ; CHECK-NEXT:    s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
 ; CHECK-NEXT:    s_mov_b32 s4, s33
 ; CHECK-NEXT:    s_mov_b32 s33, s32
 ; CHECK-NEXT:    v_mov_b32_e32 v0, 0
 ; CHECK-NEXT:    s_mov_b32 s33, s4
 ; CHECK-NEXT:    s_setpc_b64 s[30:31]
   %1 = alloca i32, align 4, addrspace(5)
; CHECK-NEXT:    s_setpc_b64 s[30:31]
   br label %15
 
   ret i32 0
 }
 
 define dso_local i32 @main() #0 {
 ; CHECK-LABEL: main:
 ; CHECK:       main$local:
+; CHECK-NEXT:    .type main$local,@function
 ; CHECK-NEXT:  ; %bb.0:
 ; CHECK-NEXT:    s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
 ; CHECK-NEXT:    s_mov_b32 s6, s33
 ; CHECK-NEXT:    s_mov_b32 s33, s32
 ; CHECK-NEXT:    s_getpc_b64 s[4:5]
 ; CHECK-NEXT:    s_add_u32 s4, s4, x@rel32@lo+4
 ; CHECK-NEXT:    s_addc_u32 s5, s5, x@rel32@hi+12
 ; CHECK-NEXT:    v_mov_b32_e32 v2, 1

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/lanai_generated_funcs.ll.generated.expected

define dso_local i32 @main() #0 {
   store i32 3, i32* %4, align 4
   store i32 4, i32* %5, align 4
   ret i32 0
 }
 
 attributes #0 = { noredzone nounwind ssp uwtable "frame-pointer"="all" }
 ; CHECK-LABEL: check_boundaries:
 ; CHECK:       .Lcheck_boundaries$local:
+; CHECK-NEXT:    .type .Lcheck_boundaries$local,@function
 ; CHECK-NEXT:    .cfi_startproc
 ; CHECK-NEXT:  ! %bb.0:
 ; CHECK-NEXT:    st %fp, [--%sp]
 ; CHECK-NEXT:    add %sp, 0x8, %fp
 ; CHECK-NEXT:    sub %sp, 0x20, %sp
 ; CHECK-NEXT:    st %r0, -12[%fp]
 ; CHECK-NEXT:    sub.f %r0, 0x0, %r0
 ; CHECK-NEXT:    st %r0, -16[%fp]

 ; CHECK-NEXT:  .LBB0_6:
 ; CHECK-NEXT:    or %r0, 0x0, %rv
 ; CHECK-NEXT:    ld -4[%fp], %pc ! return
 ; CHECK-NEXT:    add %fp, 0x0, %sp
 ; CHECK-NEXT:    ld -8[%fp], %fp
 ;
 ; CHECK-LABEL: main:
 ; CHECK:       .Lmain$local:
+; CHECK-NEXT:    .type .Lmain$local,@function
 ; CHECK-NEXT:    .cfi_startproc
 ; CHECK-NEXT:  ! %bb.0:
 ; CHECK-NEXT:    st %fp, [--%sp]
 ; CHECK-NEXT:    add %sp, 0x8, %fp
 ; CHECK-NEXT:    sub %sp, 0x20, %sp
 ; CHECK-NEXT:    st %r0, -12[%fp]
 ; CHECK-NEXT:    mov hi(x), %r3
 ; CHECK-NEXT:    or %r3, lo(x), %r3

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/lanai_generated_funcs.ll.nogenerated.expected

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -enable-machine-outliner -mtriple=lanai-unknown-linux < %s | FileCheck %s
 
 ; NOTE: Machine outliner doesn't run.
 @x = global i32 0, align 4
 
 define dso_local i32 @check_boundaries() #0 {
 ; CHECK-LABEL: check_boundaries:
 ; CHECK:       .Lcheck_boundaries$local:
+; CHECK-NEXT:    .type .Lcheck_boundaries$local,@function
 ; CHECK-NEXT:    .cfi_startproc
 ; CHECK-NEXT:  ! %bb.0:
 ; CHECK-NEXT:    st %fp, [--%sp]
 ; CHECK-NEXT:    add %sp, 0x8, %fp
 ; CHECK-NEXT:    sub %sp, 0x20, %sp
 ; CHECK-NEXT:    st %r0, -12[%fp]
 ; CHECK-NEXT:    sub.f %r0, 0x0, %r0
 ; CHECK-NEXT:    st %r0, -16[%fp]
; CHECK-NEXT:    ld -8[%fp], %fp
   br label %15
 
   ret i32 0
 }
 
 define dso_local i32 @main() #0 {
 ; CHECK-LABEL: main:
 ; CHECK:       .Lmain$local:
+; CHECK-NEXT:    .type .Lmain$local,@function
 ; CHECK-NEXT:    .cfi_startproc
 ; CHECK-NEXT:  ! %bb.0:
 ; CHECK-NEXT:    st %fp, [--%sp]
 ; CHECK-NEXT:    add %sp, 0x8, %fp
 ; CHECK-NEXT:    sub %sp, 0x20, %sp
 ; CHECK-NEXT:    st %r0, -12[%fp]
 ; CHECK-NEXT:    mov hi(x), %r3
 ; CHECK-NEXT:    or %r3, lo(x), %r3

llvm/utils/UpdateTestChecks/asm.py

else:
   import string
 
 # RegEx: this is where the magic happens.
 
 ##### Assembly parser
 
 ASM_FUNCTION_X86_RE = re.compile(
     r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*(@"?(?P=func)"?| -- Begin function (?P=func))\n(?:\s*\.?Lfunc_begin[^:\n]*:\n)?'
-    r'(?:\.L[^$]+\$local:\n)?'      # drop .L<func>$local:
+    r'(?:\.L(?P=func)\$local:\n)?'      # drop .L<func>$local:
+    r'(?:\s*\.type\s+\.L(?P=func)\$local,@function\n)?'  # drop .type .L<func>$local
     r'(?:[ \t]+.cfi_startproc\n|.seh_proc[^\n]+\n)?'  # drop optional cfi
     r'(?P<body>^##?[ \t]+[^:]+:.*?)\s*'
     r'^\s*(?:[^:\n]+?:\s*\n\s*\.size|\.cfi_endproc|\.globl|\.comm|\.(?:sub)?section|#+ -- End function)',
     flags=(re.M | re.S))
 
 ASM_FUNCTION_ARM_RE = re.compile(
     r'^(?P<func>[0-9a-zA-Z_$]+):\n' # f: (name of function)
     r'(?:\.L(?P=func)\$local:\n)?'  # drop .L<func>$local:
+    r'(?:\s*\.type\s+\.L(?P=func)\$local,@function\n)?'  # drop .type .L<func>$local
     r'\s+\.fnstart\n' # .fnstart
     r'(?P<body>.*?)' # (body of the function)
     r'^.Lfunc_end[0-9]+:', # .Lfunc_end0: or # -- End function
     flags=(re.M | re.S))
 
 ASM_FUNCTION_AARCH64_RE = re.compile(
      r'^_?(?P<func>[^:]+):[ \t]*\/\/[ \t]*@"?(?P=func)"?( (Function|Tail Call))?\n'
      r'(?:[ \t]+.cfi_startproc\n)?'  # drop optional cfi noise
ASM_FUNCTION_PPC_RE = re.compile(
     # This list is incomplete
     r'(?:^[ \t]*(?:\.(?:long|quad|v?byte)[ \t]+[^\n]+)\n)*'
     r'(?:\.Lfunc_end|L\.\.(?P=func))[0-9]+:\n',
     flags=(re.M | re.S))
 
 ASM_FUNCTION_RISCV_RE = re.compile(
     r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@"?(?P=func)"?\n'
     r'(?:\s*\.?L(?P=func)\$local:\n)?'  # optional .L<func>$local: due to -fno-semantic-interposition
+    r'(?:\s*\.type\s+\.?L(?P=func)\$local,@function\n)?'  # optional .type .L<func>$local
     r'(?:\s*\.?Lfunc_begin[^:\n]*:\n)?[^:]*?'
     r'(?P<body>^##?[ \t]+[^:]+:.*?)\s*'
     r'.Lfunc_end[0-9]+:\n',
     flags=(re.M | re.S))
 
 ASM_FUNCTION_LANAI_RE = re.compile(
     r'^_?(?P<func>[^:]+):[ \t]*!+[ \t]*@"?(?P=func)"?\n'
     r'(?:[ \t]+.cfi_startproc\n)?'  # drop optional cfi noise