AsmPrinter: mark the beginning and the end of a function in verbose mode

[thegameg]

Summary

Annotate the output with -- Begin func_name and -- End func_name if verbose mode is enabled.

This is particularly useful when using utils/abtest/abtest.py, which we used to annotate using utils/abtest/mark_aarch64fns.py and utils/abtest/mark_armfns.py, which did not work for internal functions.

• Fixed some ambiguous tests.
• Fixed abtest.py to use the new markers.
• Removed old marking scripts.
• Add AArch64 test.

[MatzeB]

Nice, but I have some nitpicks:

utils/abtest.py

13–14

Different architecures have different characters for comments. You can try out

$ grep "CommentString" lib/Target -r

to get some impression of it. Maybe we better change this script to match any line starting with 1 or 2 arbitrary characters followed by " -- Begin ".

[thegameg]

• Rename "Begin" / "End" to "Begin / End function".
• Remove the function name from the end marker.
• Fix the tests instead of adding -asm-verbose=false.
• Make abtest.py look for -- Begin function func_name and -- End function without caring about the comment symbol.

[MatzeB]

LGTM. Thanks!

Please wait a few more days for comments, and if nothing happens commit.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

639

This comment needs to be moved further down now.

test/CodeGen/AArch64/asm-print-comments.ll

4

Maybe add an extra CHECK: foo: as well? (same for bar)

utils/abtest.py

28–29

This section can be removed now.

[thegameg]

Done, thanks for the review!

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 void AsmPrinter::EmitDebugThreadLocal(const MCExpr *Value,
                                       unsigned Size) const {
   OutStreamer->EmitValue(Value, Size);
 }
 
 /// EmitFunctionHeader - This method emits the header for the current
 /// function.
 void AsmPrinter::EmitFunctionHeader() {
+  const Function *F = MF->getFunction();
+
+  if (isVerbose())
+    OutStreamer->GetCommentOS() << "-- Begin function " << F->getName() << '\n';
+
   // Print out constants referenced by the function
   EmitConstantPool();
 
   // Print the 'header' of function.
-  const Function *F = MF->getFunction();
-
   OutStreamer->SwitchSection(getObjFileLowering().SectionForGlobal(F, TM));
   EmitVisibility(CurrentFnSym, F->getVisibility());
 
   EmitLinkage(F, CurrentFnSym);
   if (MAI->hasFunctionAlignment())
     EmitAlignment(MF->getAlignment(), F);
 
   if (MAI->hasDotTypeDotSizeDirective())
void AsmPrinter::EmitFunctionBody() {
 
   // Emit post-function debug and/or EH information.
   for (const HandlerInfo &HI : Handlers) {
     NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
                        HI.TimerGroupDescription, TimePassesIsEnabled);
     HI.Handler->endFunction(MF);
   }
 
+  if (isVerbose())
+    OutStreamer->GetCommentOS() << "-- End function\n";
+
   OutStreamer->AddBlankLine();
 }
 
 /// \brief Compute the number of Global Variables that uses a Constant.
 static unsigned getNumGlobalVariableUses(const Constant *C) {
   if (!C)
     return 0;
 

test/CodeGen/AArch64/asm-print-comments.ll

+; RUN: llc %s -mtriple=arm64-apple-darwin -o - | FileCheck %s
+
+; CHECK-LABEL: ; -- Begin function foo
+; CHECK: foo:
+define hidden i32 @foo() {
+  entry:
+  ret i32 30
+}
+; CHECK: ; -- End function
+
+; CHECK-LABEL: ; -- Begin function bar
+; CHECK: bar:
+define i32 @bar() {
+  entry:
+  ret i32 30
+}
+; CHECK: ; -- End function

test/CodeGen/ARM/fastisel-thumb-litpool.ll

 ; RUN: llc -mtriple=thumbv7-apple-ios -O0 -o - %s | FileCheck %s
 
 ; We used to accidentally create both an ARM and a Thumb ldr here. It led to an
 ; assertion failure at the time, but could go all the way through to emission,
 ; hence the CHECK-NOT.
 
 define i32 @test_thumb_ldrlit() minsize {
+; CHECK-LABEL: test_thumb_ldrlit:
 ; CHECK: ldr r0, LCPI0_0
 ; CHECK-NOT: ldr
   ret i32 12345678
 }

test/CodeGen/X86/fast-isel-select-cmp.ll

 ; RUN: llc < %s -O0 -mtriple=x86_64-apple-darwin10 | FileCheck %s
 
 ; Test if we do not fold the cmp into select if the instructions are in
 ; different basic blocks.
 
 define i32 @select_cmp_cmov_i32(i32 %a, i32 %b) {
-; CHECK-LABEL: select_cmp_cmov_i32
+; CHECK-LABEL: select_cmp_cmov_i32:
 ; CHECK-LABEL: continue
-; CHECK-NOT:   cmp
+; CHECK-NOT:   cmp{{[^_]}}
   %1 = icmp ult i32 %a, %b
   br i1 %1, label %continue, label %exit
 
 continue:
   %2 = select i1 %1, i32 %a, i32 %b
   ret i32 %2
 
 exit:
   ret i32 -1
 }
 
 define float @select_fcmp_oeq_f32(float %a, float %b, float %c, float %d) {
-; CHECK-LABEL: select_fcmp_oeq_f32
+; CHECK-LABEL: select_fcmp_oeq_f32:
 ; CHECK-LABEL: continue
-; CHECK-NOT:   cmp
+; CHECK-NOT:   cmp{{[^_]}}
   %1 = fcmp oeq float %a, %b
   br i1 %1, label %continue, label %exit
 
 continue:
   %2 = select i1 %1, float %c, float %d
   ret float %2
 
 exit:
   ret float -1.0
 }
 
 define float @select_fcmp_one_f32(float %a, float %b, float %c, float %d) {
-; CHECK-LABEL: select_fcmp_one_f32
+; CHECK-LABEL: select_fcmp_one_f32:
 ; CHECK-LABEL: continue
 ; CHECK-NOT:   ucomi
   %1 = fcmp one float %a, %b
   br i1 %1, label %continue, label %exit
 
 continue:
   %2 = select i1 %1, float %c, float %d
   ret float %2
 
 exit:
   ret float -1.0
 }
 

test/CodeGen/X86/x87.ll

 ; RUN: llc < %s -march=x86 | FileCheck %s -check-prefix=X87
 ; RUN: llc < %s -march=x86-64 -mattr=-sse | FileCheck %s -check-prefix=X87
-; RUN: llc < %s -march=x86 -mattr=-x87 | FileCheck %s -check-prefix=NOX87 --implicit-check-not "{{ }}f{{.*}}"
-; RUN: llc < %s -march=x86-64 -mattr=-x87,-sse | FileCheck %s -check-prefix=NOX87 --implicit-check-not "{{ }}f{{.*}}"
-; RUN: llc < %s -march=x86 -mattr=-x87,+sse | FileCheck %s -check-prefix=NOX87 --implicit-check-not "{{ }}f{{.*}}"
-; RUN: llc < %s -march=x86-64 -mattr=-x87,-sse2 | FileCheck %s -check-prefix=NOX87 --implicit-check-not "{{ }}f{{.*}}"
+; RUN: llc < %s -march=x86 -mattr=-x87 | FileCheck %s -check-prefix=NOX87
+; RUN: llc < %s -march=x86-64 -mattr=-x87,-sse | FileCheck %s -check-prefix=NOX87
+; RUN: llc < %s -march=x86 -mattr=-x87,+sse | FileCheck %s -check-prefix=NOX87
+; RUN: llc < %s -march=x86-64 -mattr=-x87,-sse2 | FileCheck %s -check-prefix=NOX87
 
 define void @test(i32 %i, i64 %l, float* %pf, double* %pd, fp128* %pld) nounwind readnone {
 ; X87-LABEL: test:
 ; NOX87-LABEL: test:
+
+; NOX87-NOT: {{ }}f{{.*}}
+
 ; X87: fild
 ; NOX87: __floatunsisf
   %tmp = uitofp i32 %i to float
 
 ; X87: fild
 ; NOX87: __floatdisf
   %tmp1 = sitofp i64 %l to float
 

test/CodeGen/XCore/epilogue_prologue.ll

 ; RUN: llc < %s -march=xcore | FileCheck %s
 ; RUN: llc < %s -march=xcore -disable-fp-elim | FileCheck %s -check-prefix=CHECKFP
 
 ; When using SP for small frames, we don't need any scratch registers (SR).
 ; When using SP for large frames, we may need two scratch registers.
 ; When using FP, for large or small frames, we may need one scratch register.
 
 ; FP + small frame: spill FP+SR = entsp 2
-; CHECKFP-LABEL: f1
+; CHECKFP-LABEL: f1:
 ; CHECKFP: entsp 2
 ; CHECKFP-NEXT: stw r10, sp[1]
 ; CHECKFP-NEXT: ldaw r10, sp[0]
 ; CHECKFP: set sp, r10
 ; CHECKFP-NEXT: ldw r10, sp[1]
 ; CHECKFP-NEXT: retsp 2
 ;
 ; !FP + small frame: no spills = no stack adjustment needed
-; CHECK-LABEL: f1
+; CHECK-LABEL: f1:
 ; CHECK: stw lr, sp[0]
 ; CHECK: ldw lr, sp[0]
 ; CHECK-NEXT: retsp 0
 define void @f1() nounwind {
 entry:
   tail call void asm sideeffect "", "~{lr}"() nounwind
   ret void
 }
 
 
 ; FP + small frame: spill FP+SR+R0+LR = entsp 3 + extsp 1
-; CHECKFP-LABEL:f3
+; CHECKFP-LABEL: f3:
 ; CHECKFP: entsp 3
 ; CHECKFP-NEXT: stw r10, sp[1]
 ; CHECKFP-NEXT: ldaw r10, sp[0]
 ; CHECKFP-NEXT: stw [[REG:r[4-9]+]], r10[2]
 ; CHECKFP-NEXT: mov [[REG]], r0
 ; CHECKFP-NEXT: extsp 1
 ; CHECKFP-NEXT: bl f2
 ; CHECKFP-NEXT: ldaw sp, sp[1]
 ; CHECKFP-NEXT: mov r0, [[REG]]
 ; CHECKFP-NEXT: ldw [[REG]], r10[2]
 ; CHECKFP-NEXT: set sp, r10
 ; CHECKFP-NEXT: ldw r10, sp[1]
 ; CHECKFP-NEXT: retsp 3
 ;
 ; !FP + small frame: spill R0+LR = entsp 2
-; CHECK-LABEL: f3
+; CHECK-LABEL: f3:
 ; CHECK: entsp 2
 ; CHECK-NEXT: stw [[REG:r[4-9]+]], sp[1]
 ; CHECK-NEXT: mov [[REG]], r0
 ; CHECK-NEXT: bl f2
 ; CHECK-NEXT: mov r0, [[REG]]
 ; CHECK-NEXT: ldw [[REG]], sp[1]
 ; CHECK-NEXT: retsp 2
 declare void @f2()
 define i32 @f3(i32 %i) nounwind {
 entry:
   call void @f2()
   ret i32 %i
 }
 
 
 ; FP + large frame: spill FP+SR = entsp 2 + 100000
-; CHECKFP-LABEL: f4
+; CHECKFP-LABEL: f4:
 ; CHECKFP: entsp 65535
 ; CHECKFP-NEXT: .Lcfi{{[0-9]+}}
 ; CHECKFP-NEXT: .cfi_def_cfa_offset 262140
 ; CHECKFP-NEXT: .Lcfi{{[0-9]+}}
 ; CHECKFP-NEXT: .cfi_offset 15, 0
 ; CHECKFP-NEXT: extsp 34467
 ; CHECKFP-NEXT: .Lcfi{{[0-9]+}}
 ; CHECKFP-NEXT: .cfi_def_cfa_offset 400008
 ; CHECKFP-NEXT: stw r10, sp[1]
 ; CHECKFP-NEXT: .Lcfi{{[0-9]+}}
 ; CHECKFP-NEXT: .cfi_offset 10, -400004
 ; CHECKFP-NEXT: ldaw r10, sp[0]
 ; CHECKFP-NEXT: .Lcfi{{[0-9]+}}
 ; CHECKFP-NEXT: .cfi_def_cfa_register 10
 ; CHECKFP-NEXT: set sp, r10
 ; CHECKFP-NEXT: ldw r10, sp[1]
 ; CHECKFP-NEXT: ldaw sp, sp[65535]
 ; CHECKFP-NEXT: retsp 34467
 ;
 ; !FP + large frame: spill SR+SR = entsp 2 + 100000
-; CHECK-LABEL: f4
+; CHECK-LABEL: f4:
 ; CHECK: entsp 65535
 ; CHECK-NEXT: .Lcfi{{[0-9]+}}
 ; CHECK-NEXT: .cfi_def_cfa_offset 262140
 ; CHECK-NEXT: .Lcfi{{[0-9]+}}
 ; CHECK-NEXT: .cfi_offset 15, 0
 ; CHECK-NEXT: extsp 34467
 ; CHECK-NEXT: .Lcfi{{[0-9]+}}
 ; CHECK-NEXT: .cfi_def_cfa_offset 400008

 ; FP + large frame: spill FP+SR+R4+LR = entsp 3 + 200000  + extsp 1
 ; CHECKFP: .section .cp.rodata.cst4,"aMc",@progbits,4
 ; CHECKFP-NEXT: .p2align 2
 ; CHECKFP-NEXT: .LCPI[[CNST0:[0-9_]+]]:
 ; CHECKFP-NEXT: .long 200002
 ; CHECKFP-NEXT: .LCPI[[CNST1:[0-9_]+]]:
 ; CHECKFP-NEXT: .long 200001
 ; CHECKFP-NEXT: .text
-; CHECKFP-LABEL: f6
+; CHECKFP-LABEL: f6:
 ; CHECKFP: entsp 65535
 ; CHECKFP-NEXT: .Lcfi{{[0-9]+}}
 ; CHECKFP-NEXT: .cfi_def_cfa_offset 262140
 ; CHECKFP-NEXT: .Lcfi{{[0-9]+}}
 ; CHECKFP-NEXT: .cfi_offset 15, 0
 ; CHECKFP-NEXT: extsp 65535
 ; CHECKFP-NEXT: .Lcfi{{[0-9]+}}
 ; CHECKFP-NEXT: .cfi_def_cfa_offset 524280

 ; !FP + large frame: spill SR+SR+R4+LR = entsp 4 + 200000
 ; CHECK: .section .cp.rodata.cst4,"aMc",@progbits,4
 ; CHECK-NEXT: .p2align 2
 ; CHECK-NEXT: .LCPI[[CNST0:[0-9_]+]]:
 ; CHECK-NEXT: .long 200003
 ; CHECK-NEXT: .LCPI[[CNST1:[0-9_]+]]:
 ; CHECK-NEXT: .long 200002
 ; CHECK-NEXT: .text
-; CHECK-LABEL: f6
+; CHECK-LABEL: f6:
 ; CHECK: entsp 65535
 ; CHECK-NEXT: .Lcfi{{[0-9]+}}
 ; CHECK-NEXT: .cfi_def_cfa_offset 262140
 ; CHECK-NEXT: .Lcfi{{[0-9]+}}
 ; CHECK-NEXT: .cfi_offset 15, 0
 ; CHECK-NEXT: extsp 65535
 ; CHECK-NEXT: .Lcfi{{[0-9]+}}
 ; CHECK-NEXT: .cfi_def_cfa_offset 524280
entry:
   %1 = getelementptr inbounds [200000 x i32], [200000 x i32]* %0, i32 0, i32 0
   call void @f5(i32* %1)
   %2 = getelementptr inbounds [200000 x i32], [200000 x i32]* %0, i32 0, i32 199999
   call void @f5(i32* %2)
   ret i32 %i
 }
 
 ; FP + large frame: spill FP+SR+LR = entsp 2 + 256  + extsp 1
-; CHECKFP-LABEL:f8
+; CHECKFP-LABEL: f8:
 ; CHECKFP: entsp 258
 ; CHECKFP-NEXT: stw r10, sp[1]
 ; CHECKFP-NEXT: ldaw r10, sp[0]
 ; CHECKFP-NEXT: mkmsk [[REG:r[0-9]+]], 8
 ; CHECKFP-NEXT: ldaw r0, r10{{\[}}[[REG]]{{\]}}
 ; CHECKFP-NEXT: extsp 1
 ; CHECKFP-NEXT: bl f5
 ; CHECKFP-NEXT: ldaw sp, sp[1]
 ; CHECKFP-NEXT: set sp, r10
 ; CHECKFP-NEXT: ldw r10, sp[1]
 ; CHECKFP-NEXT: retsp 258
 ;
 ; !FP + large frame: spill SR+SR+LR = entsp 3 + 256
-; CHECK-LABEL:f8
+; CHECK-LABEL: f8:
 ; CHECK: entsp 257
 ; CHECK-NEXT: ldaw r0, sp[254]
 ; CHECK-NEXT: bl f5
 ; CHECK-NEXT: retsp 257
 define void @f8() nounwind {
 entry:
   %0 = alloca [256 x i32]
   %1 = getelementptr inbounds [256 x i32], [256 x i32]* %0, i32 0, i32 253
   call void @f5(i32* %1)
   ret void
 }
 
 ; FP + large frame: spill FP+SR+LR = entsp 2 + 32768  + extsp 1
-; CHECKFP-LABEL:f9
+; CHECKFP-LABEL: f9:
 ; CHECKFP: entsp 32770
 ; CHECKFP-NEXT: stw r10, sp[1]
 ; CHECKFP-NEXT: ldaw r10, sp[0]
 ; CHECKFP-NEXT: ldc [[REG:r[0-9]+]], 32767
 ; CHECKFP-NEXT: ldaw r0, r10{{\[}}[[REG]]{{\]}}
 ; CHECKFP-NEXT: extsp 1
 ; CHECKFP-NEXT: bl f5
 ; CHECKFP-NEXT: ldaw sp, sp[1]
 ; CHECKFP-NEXT: set sp, r10
 ; CHECKFP-NEXT: ldw r10, sp[1]
 ; CHECKFP-NEXT: retsp 32770
 ;
 ; !FP + large frame: spill SR+SR+LR = entsp 3 + 32768
-; CHECK-LABEL:f9
+; CHECK-LABEL: f9:
 ; CHECK: entsp 32771
 ; CHECK-NEXT: ldaw r0, sp[32768]
 ; CHECK-NEXT: bl f5
 ; CHECK-NEXT: retsp 32771
 define void @f9() nounwind {
 entry:
   %0 = alloca [32768 x i32]
   %1 = getelementptr inbounds [32768 x i32], [32768 x i32]* %0, i32 0, i32 32765
   call void @f5(i32* %1)
   ret void
 }

utils/abtest.py

 #!/usr/bin/env python
 #
 # Given a previous good compile narrow down miscompiles.
 # Expects two directories named "before" and "after" each containing a set of
 # assembly or object files where the "after" version is assumed to be broken.
 # You also have to provide a script called "link_test". It is called with a list
 # of files which should be linked together and result tested. "link_test" should
 # returns with exitcode 0 if the linking and testing succeeded.
 #
 # abtest.py operates by taking all files from the "before" directory and
 # in each step replacing one of them with a file from the "bad" directory.
 #
 # Additionally you can perform the same steps with a single .s file. In this
-# mode functions are identified by "# -- Begin FunctionName" and
-# "# -- End FunctionName" markers. The abtest.py then takes all functions from
-# the file in the "before" directory and replaces one function with the
-# corresponding function from the "bad" file in each step.
+# mode functions are identified by " -- Begin function FunctionName" and
+# " -- End function" markers. The abtest.py then takes all
+# function from the file in the "before" directory and replaces one function
+# with the corresponding function from the "bad" file in each step.
 #
 # Example usage to identify miscompiled files:
 #    1. Create a link_test script, make it executable. Simple Example:
 #          clang "$@" -o /tmp/test && /tmp/test || echo "PROBLEM"
 #    2. Run the script to figure out which files are miscompiled:
 #       > ./abtest.py 
 #       somefile.s: ok
 #       someotherfile.s: skipped: same content
 #       anotherfile.s: failed: './link_test' exitcode != 0
 #       ...
 # Example usage to identify miscompiled functions inside a file:
-#    3. First you have to mark begin and end of the functions.
-#       The script comes with some examples called mark_xxx.py.
-#       Unfortunately this is very specific to your environment and it is likely
-#       that you have to write a custom version for your environment.
-#       > for i in before/*.s after/*.s; do mark_xxx.py $i; done
-#    4. Run the tests on a single file (assuming before/file.s and
+#    3. Run the tests on a single file (assuming before/file.s and
 #       after/file.s exist)
 #       > ./abtest.py file.s
 #       funcname1 [0/XX]: ok
 #       funcname2 [1/XX]: ok
 #       funcname3 [2/XX]: skipped: same content
 #       funcname4 [3/XX]: failed: './link_test' exitcode != 0
 #       ...
 from fnmatch import filter

 
 def warn(message):
     stderr.write("Warning: %s\n" % (message,))
 
 def extract_functions(file):
     functions = []
     in_function = None
     for line in open(file):
-        if line.startswith("# -- Begin  "):
+        marker = line.find(" -- Begin function ")
+        if marker != -1:
             if in_function != None:
                 warn("Missing end of function %s" % (in_function,))
-            funcname = line[12:-1]
+            funcname = line[marker + 19:-1]
             in_function = funcname
             text = line
-        elif line.startswith("# -- End  "):
-            function_name = line[10:-1]
-            if in_function != function_name:
-                warn("End %s does not match begin %s" % (function_name, in_function))
-            else:
-                text += line
-                functions.append( (in_function, text) )
+            continue
+
+        marker = line.find(" -- End function")
+        if marker != -1:
             in_function = None
-        elif in_function != None:
+            continue
+
+        if in_function != None:
             text += line
     return functions
 
 def replace_function(file, function, replacement, dest):
     out = open(dest, "w")
     skip = False
     found = False
     in_function = None
     for line in open(file):
-        if line.startswith("# -- Begin  "):
+        marker = line.find(" -- Begin function ")
+        if marker != -1:
             if in_function != None:
                 warn("Missing end of function %s" % (in_function,))
-            funcname = line[12:-1]
+            funcname = line[marker + 19:-1]
             in_function = funcname
             if in_function == function:
                 out.write(replacement)
                 skip = True
-        elif line.startswith("# -- End  "):
-            function_name = line[10:-1]
-            if in_function != function_name:
-                warn("End %s does not match begin %s" % (function_name, in_function))
+        else:
+            marker = line.find(" -- End function")
+            if marker != -1:
                 in_function = None
                 if skip:
                     skip = False
                     continue
+
         if not skip:
             out.write(line)
 
 def announce_test(name):
     stderr.write("%s%s%s: " % (BOLD, name, NORMAL))
     stderr.flush()
 
 def announce_result(result, info):

utils/abtest/mark_aarch64fns.py

-#!/usr/bin/env python
-#
-# Mark functions in an arm assembly file. This is done by surrounding the
-# function with "# -- Begin Name" and "# -- End Name"
-# (This script is designed for aarch64 ios assembly syntax)
-import sys
-import re
-
-inp = open(sys.argv[1], "r").readlines()
-
-# First pass
-linenum = 0
-INVALID=-100
-last_align = INVALID
-last_code = INVALID
-last_globl = INVALID
-last_globl_name = None
-begin = INVALID
-in_text_section = False
-begins = dict()
-for line in inp:
-    linenum += 1
-    if re.search(r'.section\s+__TEXT,__text,regular,pure_instructions', line):
-        in_text_section = True
-        continue
-    elif ".section" in line:
-        in_text_section = False
-        continue
-
-    if not in_text_section:
-        continue
-
-    if ".align" in line:
-        last_align = linenum
-    gl = re.search(r'.globl\s+(\w+)', line)
-    if gl:
-        last_globl_name = gl.group(1)
-        last_globl = linenum
-    m = re.search(r'^(\w+):', line)
-    if m and begin == INVALID:
-        labelname = m.group(1)
-        if last_globl+2 == linenum and last_globl_name == labelname:
-            begin = last_globl
-            funcname = labelname
-    if line == "\n" and begin != INVALID:
-        end = linenum
-        triple = (funcname, begin, end)
-        begins[begin] = triple
-        begin = INVALID
-
-# Second pass: Mark
-out = open(sys.argv[1], "w")
-in_func = None
-linenum = 0
-for line in inp:
-    linenum += 1
-    if in_func is not None and linenum == end:
-        out.write("# -- End  %s\n" % in_func)
-        in_func = None
-
-    triple = begins.get(linenum)
-    if triple is not None:
-        in_func, begin, end = triple
-        out.write("# -- Begin  %s\n" % in_func)
-    out.write(line)

utils/abtest/mark_armfns.py

-#!/usr/bin/env python
-#
-# Mark functions in an arm assembly file. This is done by surrounding the
-# function with "# -- Begin Name" and "# -- End Name"
-# (This script is designed for arm ios assembly syntax)
-import sys
-import re
-
-inp = open(sys.argv[1], "r").readlines()
-
-# First pass
-linenum = 0
-INVALID=-100
-last_align = INVALID
-last_code = INVALID
-last_globl = INVALID
-begin = INVALID
-begins = dict()
-for line in inp:
-    linenum += 1
-    if ".align" in line:
-        last_align = linenum
-    if ".code" in line:
-        last_code = linenum
-    if ".globl" in line:
-        last_globl = linenum
-    m = re.search(r'.thumb_func\s+(\w+)', line)
-    if m:
-        funcname = m.group(1)
-        if last_code == last_align+1 and (linenum - last_code) < 4:
-            begin = last_align
-            if last_globl+1 == last_align:
-                begin = last_globl
-    if line == "\n" and begin != INVALID:
-        end = linenum
-        triple = (funcname, begin, end)
-        begins[begin] = triple
-        begin = INVALID
-
-# Second pass: Mark
-out = open(sys.argv[1], "w")
-in_func = None
-linenum = 0
-for line in inp:
-    linenum += 1
-    if in_func is not None and linenum == end:
-        out.write("# -- End  %s\n" % in_func)
-        in_func = None
-
-    triple = begins.get(linenum)
-    if triple is not None:
-        in_func, begin, end = triple
-        out.write("# -- Begin  %s\n" % in_func)
-    out.write(line)