[UpdateTestChecks] Fix `update_test_checks.py` to add "unused" prefixes

[mtrofin]

Summary

The support introduced in D124306 was only added to update_llc_test_checks.py, but the motivating usecases (see https://lists.llvm.org/pipermail/llvm-dev/2021-February/148326.html) cover update_test_checks.py, update_cc_test_checks.py, and update_analyze_test_checks.py, too.

Issue #59220.

[lebedev.ri]

Please also fix the *_analysis one too.

[lebedev.ri]

(and maybe the _cc one?)

[mtrofin]

In D138836#3954268, @lebedev.ri wrote:

(and maybe the _cc one?)

Good point, let me look at the other few there, too.

[mtrofin]

fixed the other 2 scripts

[lebedev.ri]

Thanks!
There's also the one for MCA, but this situation basically never happens for those tests.

[mtrofin]

missed one

[mtrofin]

In D138836#3954782, @lebedev.ri wrote:

Thanks!
There's also the one for MCA, but this situation basically never happens for those tests.

Yup, checked that and the mir one. The latter seems to be implementing its own "add_checks", so would leave it as-is (plus, I'm guessing, by their nature, mir tests wouldn't get into this type of scenario anyway, IIUC).

[lebedev.ri]

In D138836#3954850, @mtrofin wrote:

In D138836#3954782, @lebedev.ri wrote:

Thanks!
There's also the one for MCA, but this situation basically never happens for those tests.

Yup, checked that and the mir one. The latter seems to be implementing its own "add_checks", so would leave it as-is (plus, I'm guessing, by their nature, mir tests wouldn't get into this type of scenario anyway, IIUC).

mca!=mir

[mtrofin]

In D138836#3954851, @lebedev.ri wrote:

In D138836#3954850, @mtrofin wrote:

In D138836#3954782, @lebedev.ri wrote:

Thanks!
There's also the one for MCA, but this situation basically never happens for those tests.

Yup, checked that and the mir one. The latter seems to be implementing its own "add_checks", so would leave it as-is (plus, I'm guessing, by their nature, mir tests wouldn't get into this type of scenario anyway, IIUC).

mca!=mir

Right - they are different, there's a update_mir_test_checks and also an update_mca_test_checks; basically agreeing that, indeed, after patching _cc and _analysis (and update_test_checks), the remaining don't need patching.

[lebedev.ri]

Anyways, assuming you tested that this works, LG.
Thank you.

clang/test/utils/update_cc_test_checks/Inputs/prefix-never-matches.cpp.expected

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -O0 -o - %s | FileCheck %s -check-prefix=A
+// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -O3 -o - %s | FileCheck %s -check-prefix=A
+
+int foo(int i ) {
+    return 1;
+}
+//// NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+// A: {{.*}}

clang/test/utils/update_cc_test_checks/prefix-never-matches.test

 # RUN: cp -f %S/Inputs/prefix-never-matches.cpp %t.cpp
-# RUN: %update_cc_test_checks %t.cpp 2>&1 | FileCheck %s
-# RUN: FileCheck --input-file=%t.cpp %s --check-prefix=OUTPUT
-
-# CHECK: WARNING: Prefix A had conflicting output
-# OUTPUT-NOT: A:
+# RUN: %update_cc_test_checks %t.cpp
+# RUN: diff -u %t.cpp %S/Inputs/prefix-never-matches.cpp.expected
 

llvm/test/Transforms/InstCombine/widen-load-of-small-alloca.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=instcombine -data-layout="e-n8:16:32:64" -S %s | FileCheck %s --check-prefixes=CHECK-ALL
-; RUN: opt -passes=instcombine -data-layout="e-n8:16:32" -S %s | FileCheck %s --check-prefixes=CHECK-ALL
-; RUN: opt -passes=instcombine -data-layout="E-n8:16:32:64" -S %s | FileCheck %s --check-prefixes=CHECK-ALL
-; RUN: opt -passes=instcombine -data-layout="E-n8:16:32" -S %s | FileCheck %s --check-prefixes=CHECK-ALL
+; RUN: opt -passes=instcombine -data-layout="e-n8:16:32:64" -S %s | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-SCALAR,CHECK-SCALAR-64,CHECK-LE-64
+; RUN: opt -passes=instcombine -data-layout="e-n8:16:32" -S %s | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-SCALAR,CHECK-SCALAR-32,CHECK-LE-32
+; RUN: opt -passes=instcombine -data-layout="E-n8:16:32:64" -S %s | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-SCALAR,CHECK-SCALAR-64,CHECK-BE-64
+; RUN: opt -passes=instcombine -data-layout="E-n8:16:32" -S %s | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-SCALAR,CHECK-SCALAR-32,CHECK-BE-32
 
 define void @load-1byte-chunk-of-1byte-alloca(ptr %src, i64 %byteOff, ptr %escape) {
 ; CHECK-ALL-LABEL: @load-1byte-chunk-of-1byte-alloca(
 ; CHECK-ALL-NEXT:    [[INTERMEDIATE:%.*]] = alloca [1 x i8], align 64
 ; CHECK-ALL-NEXT:    [[INIT:%.*]] = load <1 x i8>, ptr [[SRC:%.*]], align 1
 ; CHECK-ALL-NEXT:    store <1 x i8> [[INIT]], ptr [[INTERMEDIATE]], align 64
 ; CHECK-ALL-NEXT:    call void @use.v1i8(<1 x i8> [[INIT]])
 ; CHECK-ALL-NEXT:    call void @use.ptr(ptr nonnull [[INTERMEDIATE]])

 
 declare void @use.ptr(ptr)
 declare void @use.v1i8(<1 x i8>)
 declare void @use.v2i8(<2 x i8>)
 declare void @use.v4i8(<4 x i8>)
 declare void @use.v8i8(<8 x i8>)
 declare void @use.v16i8(<16 x i8>)
 declare void @use.v32i8(<32 x i8>)
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; CHECK-ALL: {{.*}}
+; CHECK-BE-32: {{.*}}
+; CHECK-BE-64: {{.*}}
+; CHECK-LE-32: {{.*}}
+; CHECK-LE-64: {{.*}}
+; CHECK-SCALAR: {{.*}}
+; CHECK-SCALAR-32: {{.*}}
+; CHECK-SCALAR-64: {{.*}}

llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/x86-loopvectorize-costmodel.ll.expected

for.body:
 
   %iv.next = add nuw nsw i64 %iv.0, 2
   %cmp = icmp ult i64 %iv.next, 1024
   br i1 %cmp, label %for.body, label %for.cond.cleanup
 
 for.cond.cleanup:
   ret void
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; AVX512: {{.*}}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/check_attrs.ll.funcattrs.expected

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S]], i64 1, i32 2, i32 1, i64 5, i64 13
 ; CHECK-NEXT:    ret i32* [[ARRAYIDX]]
 ;
 entry:
   %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
   ret i32* %arrayidx
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; IS__CGSCC____: {{.*}}
+; IS__TUNIT____: {{.*}}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/check_attrs.ll.plain.expected

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S]], i64 1, i32 2, i32 1, i64 5, i64 13
 ; CHECK-NEXT:    ret i32* [[ARRAYIDX]]
 ;
 entry:
   %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
   ret i32* %arrayidx
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; IS__CGSCC____: {{.*}}
+; IS__TUNIT____: {{.*}}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/function_name.ll.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Check that we accept functions with '$' in the name.
 ;
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 ;
 define hidden i32 @"_Z54bar$ompvariant$bar"() {
 entry:
   ret i32 2
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; CHECK: {{.*}}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/prefix-never-matches.ll.expected

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -O0 -S < %s  | FileCheck %s -check-prefix=A
+; RUN: opt -O3 -S < %s  | FileCheck %s -check-prefix=A
+
+define i32 @foo(i32 %i) {
+  %r = add i32 1, 1
+  ret i32 %r
+}
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; A: {{.*}}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/sometimes_deleted_function.ll.expected

 }
 
 define void @always_here() {
 ; ALL-LABEL: @always_here(
 ; ALL-NEXT:    ret void
 ;
   ret void
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; ALL_BUT_FOUR: {{.*}}
+; ALL_BUT_ONE: {{.*}}
+; ALL_BUT_THREE: {{.*}}
+; ALL_BUT_TWO: {{.*}}
+; FOUR: {{.*}}
+; ONE: {{.*}}
+; ONE_AND_THREE: {{.*}}
+; ONE_AND_TWO: {{.*}}
+; THREE_AND_FOUR: {{.*}}
+; TWO: {{.*}}
+; TWO_AND_FOUR: {{.*}}
+; TWO_AND_THREE: {{.*}}

llvm/test/tools/UpdateTestChecks/update_test_checks/prefix-never-matches.test

 # RUN: cp -f %S/Inputs/prefix-never-matches.ll %t.ll
-# RUN: %update_test_checks %t.ll 2>&1 | FileCheck %s
-# RUN: FileCheck --input-file=%t.ll %s --check-prefix=OUTPUT
-
-# CHECK: WARNING: Prefix A had conflicting output
-# OUTPUT-NOT: A:
+# RUN: %update_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/prefix-never-matches.ll.expected
 

llvm/utils/UpdateTestChecks/common.py

for line_info in self.ro_iterlines():
       self.args = line_info.args
       self.argv = line_info.argv
       if not self.args.enabled:
         output_lines.append(input_line)
         continue
       yield line_info
 
   def get_checks_for_unused_prefixes(self, run_list, used_prefixes: List[str]) -> List[str]:
-    unused_prefixes = set(
-        [prefix for sublist in run_list for prefix in sublist[0]]).difference(set(used_prefixes))
+    run_list = [element for element in run_list if element[0] is not None]
+    unused_prefixes = set([
+        prefix for sublist in run_list for prefix in sublist[0]
+    ]).difference(set(used_prefixes))
 
     ret = []
     if not unused_prefixes:
       return ret
     ret.append(self.test_unused_note)
     for unused in sorted(unused_prefixes):
       ret.append('{comment} {prefix}: {match_everything}'.format(
         comment=self.comment_prefix,
def __init__(self, run_list, flags, scrubber_args, path):
     # Strip double-quotes if input was read by UTC_ARGS
     self._replace_value_regex = list(map(lambda x: x.strip('"'), flags.replace_value_regex))
     self._func_dict = {}
     self._func_order = {}
     self._global_var_dict = {}
     self._processed_prefixes = set()
     for tuple in run_list:
       for prefix in tuple[0]:
-        self._func_dict.update({prefix:dict()})
+        self._func_dict.update({prefix: dict()})
         self._func_order.update({prefix: []})
-        self._global_var_dict.update({prefix:dict()})
+        self._global_var_dict.update({prefix: dict()})
 
   def finish_and_get_func_dict(self):
     for prefix in self.get_failed_prefixes():
       warn('Prefix %s had conflicting output from different RUN lines for all functions in test %s' % (prefix,self._path,))
     return self._func_dict
 
   def func_order(self):
     return self._func_order
for p in prefix_list:
         # Remembe new global variables we have not seen before
         for key in global_vars_seen:
           if key not in global_vars_seen_before:
             global_vars_seen_dict[checkprefix][key] = global_vars_seen[key]
         break
 
   if printed_prefixes:
     output_lines.append(comment_marker + SEPARATOR)
+  return printed_prefixes
 
 
 def check_prefix(prefix):
   if not PREFIX_RE.match(prefix):
     hint = ""
     if ',' in prefix:
       hint = " Did you mean '--check-prefixes=" + prefix + "'?"
     warn(("Supplied prefix '%s' is invalid. Prefix must contain only alphanumeric characters, hyphens and underscores." + hint) %
def add_checks_at_end(output_lines, prefix_list, func_order,
   for prefix in prefix_list:
     prefixes = prefix[0]
     tool_args = prefix[1]
     for prefix in prefixes:
       for func in func_order[prefix]:
         # The func order can contain the same functions multiple times.
         # If we see one again we are done.
         if (func, prefix) in added:
-            continue
         if added:
           output_lines.append(comment_string)
 
         # The add_*_checks routines expect a run list whose items are
         # tuples that have a list of prefixes as their first element and
         # tool command args string as their second element.  They output
         # checks for each prefix in the list of prefixes.  By doing so, it
         # implicitly assumes that for each function every run line will
         # generate something for that function.  That is not the case for
         # generated functions as some run lines might not generate them
         # (e.g. -fopenmp vs. no -fopenmp).
         #
         # Therefore, pass just the prefix we're interested in.  This has
         # the effect of generating all of the checks for functions of a
         # single prefix before moving on to the next prefix.  So checks
         # are ordered by prefix instead of by function as in "normal"
         # mode.
         for generated_prefix in check_generator(output_lines,
                         [([prefix], tool_args)], func):
-            added.add((func, generated_prefix))
-            generated_prefixes.add(generated_prefix)
   return generated_prefixes

llvm/utils/update_analyze_test_checks.py

for ti in common.itertests(initial_args.tests, parser,
 
     func_dict = builder.finish_and_get_func_dict()
     is_in_function = False
     is_in_function_start = False
     prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes])
     common.debug('Rewriting FileCheck prefixes:', str(prefix_set), file=sys.stderr)
     output_lines = []
 
+    generated_prefixes = []
     for input_info in ti.iterlines(output_lines):
       input_line = input_info.line
       args = input_info.args
       if is_in_function_start:
         if input_line == '':
           continue
         if input_line.lstrip().startswith(';'):
           m = common.CHECK_RE.match(input_line)
           if not m or m.group(1) not in prefix_set:
             output_lines.append(input_line)
             continue
 
         # Print out the various check lines here.
-        common.add_analyze_checks(output_lines, ';', prefix_list, func_dict, func_name,
-                                  is_filtered=builder.is_filtered())
+        generated_prefixes.extend(
+            common.add_analyze_checks(
+                output_lines,
+                ';',
+                prefix_list,
+                func_dict,
+                func_name,
+                is_filtered=builder.is_filtered()))
         is_in_function_start = False
 
       if is_in_function:
         if common.should_add_line_to_output(input_line, prefix_set):
           # This input line of the function body will go as-is into the output.
           # Except make leading whitespace uniform: 2 spaces.
           input_line = common.SCRUB_LEADING_WHITESPACE_RE.sub(r'  ', input_line)
           output_lines.append(input_line)
for input_info in ti.iterlines(output_lines):
       if not m:
         continue
       func_name = m.group(1)
       if ti.args.function is not None and func_name != ti.args.function:
         # When filtering on a specific function, skip all others.
         continue
       is_in_function = is_in_function_start = True
 
+    if ti.args.gen_unused_prefix_body:
+      output_lines.extend(
+          ti.get_checks_for_unused_prefixes(prefix_list, generated_prefixes))
+
     common.debug('Writing %d lines to %s...' % (len(output_lines), ti.path))
 
     with open(ti.path, 'wb') as f:
       f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
 
 
 if __name__ == '__main__':
   main()

llvm/utils/update_cc_test_checks.py

for ti in common.itertests(initial_args.tests, parser, 'utils/' + script_name,
     prefix_set = set([prefix for p in filecheck_run_list for prefix in p[0]])
     output_lines = []
     has_checked_pre_function_globals = False
 
     include_generated_funcs = common.find_arg_in_test(ti,
                                                       lambda args: ti.args.include_generated_funcs,
                                                       '--include-generated-funcs',
                                                       True)
-
+    generated_prefixes = []
     if include_generated_funcs:
       # Generate the appropriate checks for each function.  We need to emit
       # these in the order according to the generated output so that CHECK-LABEL
       # works properly.  func_order provides that.
 
       # It turns out that when clang generates functions (for example, with
       # -fopenmp), it can sometimes cause functions to be re-ordered in the
       # output, even functions that exist in the source file.  Therefore we
if include_generated_funcs:
                                       is_filtered=builder.is_filtered())
         else:
           return asm.add_checks(my_output_lines, '//',
                                 prefixes,
                                 func_dict, func, global_vars_seen_dict,
                                 is_filtered=builder.is_filtered())
 
       if ti.args.check_globals:
+        generated_prefixes.extend(
             common.add_global_checks(builder.global_var_dict(), '//', run_list,
                                      output_lines, global_vars_seen_dict, True,
-                                 True)
-      common.add_checks_at_end(output_lines, filecheck_run_list, builder.func_order(),
-                               '//', lambda my_output_lines, prefixes, func:
-                               check_generator(my_output_lines,
-                                               prefixes, func))
+                                     True))
+      generated_prefixes.extend(
+          common.add_checks_at_end(
+              output_lines, filecheck_run_list, builder.func_order(), '//',
+              lambda my_output_lines, prefixes, func: check_generator(
+                  my_output_lines, prefixes, func)))
     else:
       # Normal mode.  Put checks before each source function.
       for line_info in ti.iterlines(output_lines):
         idx = line_info.line_number
         line = line_info.line
         args = line_info.args
         include_line = True
         m = common.CHECK_RE.match(line)
else:
             if args.functions is None or any(re.search(regex, spell) for regex in args.functions):
               last_line = output_lines[-1].strip()
               while last_line == '//':
                 # Remove the comment line since we will generate a new  comment
                 # line as part of common.add_ir_checks()
                 output_lines.pop()
                 last_line = output_lines[-1].strip()
               if ti.args.check_globals and not has_checked_pre_function_globals:
+                generated_prefixes.extend(
                     common.add_global_checks(builder.global_var_dict(), '//',
                                              run_list, output_lines,
-                                         global_vars_seen_dict, True, True)
+                                             global_vars_seen_dict, True, True))
                 has_checked_pre_function_globals = True
               if added:
                 output_lines.append('//')
               added.add(mangled)
-              common.add_ir_checks(output_lines, '//', filecheck_run_list, func_dict, mangled,
-                                   False, args.function_signature, global_vars_seen_dict,
-                                   is_filtered=builder.is_filtered())
+              generated_prefixes.extend(
+                  common.add_ir_checks(
+                      output_lines,
+                      '//',
+                      filecheck_run_list,
+                      func_dict,
+                      mangled,
+                      False,
+                      args.function_signature,
+                      global_vars_seen_dict,
+                      is_filtered=builder.is_filtered()))
               if line.rstrip('\n') == '//':
                 include_line = False
 
         if include_line:
           output_lines.append(line.rstrip('\n'))
 
     if ti.args.check_globals:
+      generated_prefixes.extend(
           common.add_global_checks(builder.global_var_dict(), '//', run_list,
-                               output_lines, global_vars_seen_dict, True, False)
+                                   output_lines, global_vars_seen_dict, True,
+                                   False))
+    if ti.args.gen_unused_prefix_body:
+      output_lines.extend(
+          ti.get_checks_for_unused_prefixes(run_list, generated_prefixes))
     common.debug('Writing %d lines to %s...' % (len(output_lines), ti.path))
     with open(ti.path, 'wb') as f:
       f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())

llvm/utils/update_test_checks.py

for ti in common.itertests(initial_args.tests, parser,
     prefix_set = set([prefix for prefixes, _, _ in prefix_list for prefix in prefixes])
     common.debug('Rewriting FileCheck prefixes:', str(prefix_set))
     output_lines = []
 
     include_generated_funcs = common.find_arg_in_test(ti,
                                                       lambda args: ti.args.include_generated_funcs,
                                                       '--include-generated-funcs',
                                                       True)
-
+    generated_prefixes = []
     if include_generated_funcs:
       # Generate the appropriate checks for each function.  We need to emit
       # these in the order according to the generated output so that CHECK-LABEL
       # works properly.  func_order provides that.
 
       # We can't predict where various passes might insert functions so we can't
       # be sure the input function order is maintained.  Therefore, first spit
       # out all the source lines.
       common.dump_input_lines(output_lines, ti, prefix_set, ';')
 
       args = ti.args
       if args.check_globals:
-          common.add_global_checks(builder.global_var_dict(), ';', prefix_list, output_lines, global_vars_seen_dict, args.preserve_names, True)
+        generated_prefixes.extend(
+            common.add_global_checks(builder.global_var_dict(), ';',
+                                     prefix_list, output_lines,
+                                     global_vars_seen_dict, args.preserve_names,
+                                     True))
 
       # Now generate all the checks.
-      common.add_checks_at_end(output_lines, prefix_list, builder.func_order(),
-                               ';', lambda my_output_lines, prefixes, func:
-                               common.add_ir_checks(my_output_lines, ';',
-                                                    prefixes,
-                                                    func_dict, func, False,
-                                                    args.function_signature,
-                                                    global_vars_seen_dict,
-                                                    is_filtered=builder.is_filtered()))
+      generated_prefixes.extend(
+          common.add_checks_at_end(
+              output_lines, prefix_list, builder.func_order(), ';',
+              lambda my_output_lines, prefixes, func: common.add_ir_checks(
+                  my_output_lines,
+                  ';',
+                  func_dict,
+                  func,
+                  False,
+                  is_filtered=builder.is_filtered())))
     else:
       # "Normal" mode.
       for input_line_info in ti.iterlines(output_lines):
         input_line = input_line_info.line
         args = input_line_info.args
         if is_in_function_start:
           if input_line == '':
             continue
           if input_line.lstrip().startswith(';'):
             m = common.CHECK_RE.match(input_line)
             if not m or m.group(1) not in prefix_set:
               output_lines.append(input_line)
               continue
 
           # Print out the various check lines here.
-          common.add_ir_checks(output_lines, ';', prefix_list, func_dict,
-                               func_name, args.preserve_names, args.function_signature,
-                               global_vars_seen_dict,
-                               is_filtered=builder.is_filtered())
+          generated_prefixes.extend(
+              common.add_ir_checks(
+                  output_lines,
+                  ';',
+                  prefix_list,
+                  func_dict,
+                  func_name,
+                  args.preserve_names,
+                  args.function_signature,
+                  is_filtered=builder.is_filtered()))
           is_in_function_start = False
 
         m = common.IR_FUNCTION_RE.match(input_line)
         if m and not has_checked_pre_function_globals:
-            if args.check_globals:
-                common.add_global_checks(builder.global_var_dict(), ';', prefix_list, output_lines, global_vars_seen_dict, args.preserve_names, True)
-            has_checked_pre_function_globals = True
+            generated_prefixes.extend(
+                common.add_global_checks(builder.global_var_dict(), ';',
+                                         prefix_list, output_lines,
+                                         global_vars_seen_dict,
+                                         args.preserve_names, True))
 
         if common.should_add_line_to_output(input_line, prefix_set, not is_in_function):
-            # This input line of the function body will go as-is into the output.
-            # Except make leading whitespace uniform: 2 spaces.
-            input_line = common.SCRUB_LEADING_WHITESPACE_RE.sub(r'  ', input_line)
-            output_lines.append(input_line)
-            if input_line.strip() == '}':
-                 is_in_function = False
-                 continue
 
         if is_in_function:
-           continue
 
         m = common.IR_FUNCTION_RE.match(input_line)
         if not m:
           continue
         func_name = m.group(1)
         if args.function is not None and func_name != args.function:
           # When filtering on a specific function, skip all others.
           continue
         is_in_function = is_in_function_start = True
 
     if args.check_globals:
-        common.add_global_checks(builder.global_var_dict(), ';', prefix_list, output_lines, global_vars_seen_dict, args.preserve_names, False)
+      generated_prefixes.extend(
+          common.add_global_checks(builder.global_var_dict(), ';', prefix_list,
+                                   output_lines, global_vars_seen_dict,
+                                   args.preserve_names, False))
+    if ti.args.gen_unused_prefix_body:
+      output_lines.extend(ti.get_checks_for_unused_prefixes(
+          prefix_list, generated_prefixes))
     common.debug('Writing %d lines to %s...' % (len(output_lines), ti.path))
 
     with open(ti.path, 'wb') as f:
       f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
 
 
 if __name__ == '__main__':
   main()