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/abtest.py

14–15

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

631

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/abtest.py

29–33

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() {
-  // Print out constants referenced by the function
-  EmitConstantPool();
-
   // Print the 'header' of function.
   const Function *F = MF->getFunction();
 
+  if (isVerbose())
+    OutStreamer->GetCommentOS() << "-- Begin " << F->getName() << '\n';
+
+  // Print out constants referenced by the function
+  EmitConstantPool();
+
   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 " << F->getName() << '\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/arm64-misched-multimmo.ll

 ; REQUIRES: asserts
-; RUN: llc < %s -mtriple=arm64-linux-gnu -mcpu=cortex-a57 -enable-misched=0 -debug-only=misched -o - 2>&1 > /dev/null | FileCheck %s
+; RUN: llc < %s -mtriple=arm64-linux-gnu -mcpu=cortex-a57 -enable-misched=0 -debug-only=misched -asm-verbose=false -o - 2>&1 > /dev/null | FileCheck %s
 
 
 @G1 = common global [100 x i32] zeroinitializer, align 4
 @G2 = common global [100 x i32] zeroinitializer, align 4
 
 ; Check that no scheduling dependencies are created between the paired loads and the store during post-RA MI scheduling.
 ;
 ; CHECK-LABEL: # Machine code for function foo:

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

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

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

-; RUN: llc -mtriple=thumbv7-apple-ios -O0 -o - %s | FileCheck %s
+; RUN: llc -mtriple=thumbv7-apple-ios -O0 -asm-verbose=false -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: ldr r0, LCPI0_0
 ; CHECK-NOT: ldr
   ret i32 12345678
 }

test/CodeGen/ARM/ldrd.ll

-; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=cortex-a8 -regalloc=fast -optimize-regalloc=0 -verify-machineinstrs | FileCheck %s -check-prefix=A8 -check-prefix=CHECK -check-prefix=NORMAL
-; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=cortex-m3 -regalloc=fast -optimize-regalloc=0 | FileCheck %s -check-prefix=M3 -check-prefix=CHECK -check-prefix=NORMAL
+; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=cortex-a8 -regalloc=fast -optimize-regalloc=0 -verify-machineinstrs -asm-verbose=false | FileCheck %s -check-prefix=A8 -check-prefix=CHECK -check-prefix=NORMAL
+; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=cortex-m3 -regalloc=fast -optimize-regalloc=0 -asm-verbose=false | FileCheck %s -check-prefix=M3 -check-prefix=CHECK -check-prefix=NORMAL
 ; rdar://6949835
-; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=cortex-a8 -regalloc=basic | FileCheck %s -check-prefix=BASIC -check-prefix=CHECK -check-prefix=NORMAL
-; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=cortex-a8 -regalloc=greedy | FileCheck %s -check-prefix=GREEDY -check-prefix=CHECK -check-prefix=NORMAL
-; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=swift | FileCheck %s -check-prefix=SWIFT -check-prefix=CHECK -check-prefix=NORMAL
+; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=cortex-a8 -regalloc=basic -asm-verbose=false | FileCheck %s -check-prefix=BASIC -check-prefix=CHECK -check-prefix=NORMAL
+; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=cortex-a8 -regalloc=greedy -asm-verbose=false | FileCheck %s -check-prefix=GREEDY -check-prefix=CHECK -check-prefix=NORMAL
+; RUN: llc < %s -mtriple=thumbv7-apple-ios -mcpu=swift -asm-verbose=false | FileCheck %s -check-prefix=SWIFT -check-prefix=CHECK -check-prefix=NORMAL
 
-; RUN: llc < %s -mtriple=thumbv7-apple-ios -arm-assume-misaligned-load-store | FileCheck %s -check-prefix=CHECK -check-prefix=CONSERVATIVE
+; RUN: llc < %s -mtriple=thumbv7-apple-ios -arm-assume-misaligned-load-store -asm-verbose=false | FileCheck %s -check-prefix=CHECK -check-prefix=CONSERVATIVE
 
 ; Magic ARM pair hints works best with linearscan / fast.
 
 @b = external global i64*
 
 ; We use the following two to force values into specific registers.
 declare i64* @get_ptr()
 declare void @use_i64(i64 %v)

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
+define i32 @select_CMP_cmov_i32(i32 %a, i32 %b) {
+; CHECK-LABEL: select_CMP_cmov_i32
 ; CHECK-LABEL: continue
 ; 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
+define float @select_FCMP_oeq_f32(float %a, float %b, float %c, float %d) {
+; CHECK-LABEL: select_FCMP_oeq_f32
 ; CHECK-LABEL: continue
 ; 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
+define float @select_FCMP_one_f32(float %a, float %b, float %c, float %d) {
+; 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/XCore/epilogue_prologue.ll

-; RUN: llc < %s -march=xcore | FileCheck %s
-; RUN: llc < %s -march=xcore -disable-fp-elim | FileCheck %s -check-prefix=CHECKFP
+; RUN: llc < %s -march=xcore -asm-verbose=false | FileCheck %s
+; RUN: llc < %s -march=xcore -disable-fp-elim -asm-verbose=false | 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: entsp 2

utils/abtest/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
+# 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.
 #
 # 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
 #       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
 #       ...

 
 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 ")
+        if marker != -1:
             if in_function != None:
                 warn("Missing end of function %s" % (in_function,))
-            funcname = line[12:-1]
+            funcname = line[marker + 11:-1]
             in_function = funcname
             text = line
-        elif line.startswith("# -- End  "):
-            function_name = line[10:-1]
+            continue
+
+        marker = line.find("; -- End ")
+        if marker != -1:
+            function_name = line[marker + 9:-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) )
             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 ")
+        if marker != -1:
             if in_function != None:
                 warn("Missing end of function %s" % (in_function,))
-            funcname = line[12:-1]
+            funcname = line[marker + 11:-1]
             in_function = funcname
             if in_function == function:
                 out.write(replacement)
                 skip = True
-        elif line.startswith("# -- End  "):
-            function_name = line[10:-1]
+        else:
+            marker = line.find("; -- End ")
+            if marker != -1:
+                function_name = line[marker + 9:-1]
                 if in_function != function_name:
                     warn("End %s does not match begin %s" % (function_name, in_function))
                 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)