[RemarkUtil] Refactor llvm-remarkutil to include size-diff

[zjaffal]

Summary

This change follows from https://reviews.llvm.org/D156416 We include
llvm-remark-size-diff as a part of llvm-remarkutil under a
subcommand size-diff.

[thegameg]

Clean, thank you!

[paquette]

LGTM too thanks!

clang/docs/ClangFormattedStatus.rst

* - llvm/tools/llvm-reduce
      - `6`
      - `1`
      - :part:`85%`
    * - llvm/tools/llvm-reduce/deltas
      - `40`
      - `39`
      - `1`
      - :part:`97%`
-   * - llvm/tools/llvm-remark-size-diff
-     - `1`
-     - `1`
-     - `0`
-     - :good:`100%`
    * - llvm/tools/llvm-rtdyld
      - `1`
      - `0`
      - `1`
      - :none:`0%`
    * - llvm/tools/llvm-rust-demangle-fuzzer
      - `2`
      - `2`

clang/docs/tools/clang-formatted-files.txt

 llvm/tools/llvm-reduce/deltas/ReduceOperands.cpp
 llvm/tools/llvm-reduce/deltas/ReduceOperands.h
 llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.cpp
 llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.h
 llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp
 llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.h
 llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.cpp
 llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.h
-llvm/tools/llvm-remark-size-diff/RemarkSizeDiff.cpp
 llvm/tools/llvm-rust-demangle-fuzzer/DummyDemanglerFuzzer.cpp
 llvm/tools/llvm-rust-demangle-fuzzer/llvm-rust-demangle-fuzzer.cpp
 llvm/tools/llvm-shlib/libllvm.cpp
 llvm/tools/llvm-special-case-list-fuzzer/DummySpecialCaseListFuzzer.cpp
 llvm/tools/llvm-special-case-list-fuzzer/special-case-list-fuzzer.cpp
 llvm/tools/llvm-strings/llvm-strings.cpp
 llvm/tools/llvm-tapi-diff/DiffEngine.cpp
 llvm/tools/llvm-tapi-diff/DiffEngine.h

llvm/docs/CommandGuide/index.rst

.. toctree::
    llvm-tli-checker
 
 Remarks Tools
 ~~~~~~~~~~~~~~
 
 .. toctree::
    :maxdepth: 1
 
-   llvm-remark-size-diff
    llvm-remarkutil

llvm/docs/CommandGuide/llvm-remark-size-diff.rst

-llvm-remark-size-diff - diff size remarks
-=========================================
-
-.. program:: llvm-remark-size-diff
-
-SYNOPSIS
---------
-
-:program:`llvm-remark-size-diff` [*options*] *file_a* *file_b* **--parser** *parser*
-
-DESCRIPTION
------------
-
-:program:`llvm-remark-size-diff` diffs size
-`remarks <https://llvm.org/docs/Remarks.html>`_ in two remark files: ``file_a``
-and ``file_b``.
-
-:program:`llvm-remark-size-diff` can be used to gain insight into which
-functions were impacted the most by code generation changes.
-
-In most common use-cases ``file_a`` and ``file_b`` will be remarks output by
-compiling a **fixed source** with **differing compilers** or
-**differing optimization settings**.
-
-:program:`llvm-remark-size-diff` handles both
-`YAML <https://llvm.org/docs/Remarks.html#yaml-remarks>`_ and
-`bitstream <https://llvm.org/docs/Remarks.html#llvm-bitstream-remarks>`_
-remarks.
-
-OPTIONS
--------
-
-.. option:: --parser=<yaml|bitstream>
-
-  Select the type of input remark parser. Required.
-  * ``yaml``: The tool will parse YAML remarks.
-  * ``bitstream``: The tool will parse bitstream remarks.
-
-.. option:: --report-style=<human|json>
-
-  Output style.
-  * ``human``: Human-readable textual report. Default option.
-  * ``json``: JSON report.
-
-.. option:: --pretty
-
-  Pretty-print JSON output. Optional.
-
-  If output is not set to JSON, this does nothing.
-
-.. option:: -o=<file>
-
-  Output file for the report. Outputs to stdout by default.
-
-HUMAN-READABLE OUTPUT
----------------------
-
-The human-readable format for :program:`llvm-remark-size-diff` is composed of
-two sections:
-
-* Per-function changes.
-* A high-level summary of all changes.
-
-Changed Function Section
-########################
-
-Suppose you are comparing two remark files OLD and NEW.
-
-For each function with a **changed instruction count** in OLD and NEW,
-:program:`llvm-remark-size-diff` will emit a line like below:
-
-::
-
-  (++|--|==) (>|<) function_name, N instrs, M stack B
-
-A breakdown of the format is below:
-
-``(++|--|==)``
-  Which of OLD and NEW the ``function_name`` is present in.
-
-  * ``++``: Only in NEW. ("Added")
-  * ``--``: Only in OLD. ("Removed")
-  * ``==``: In both.
-
-``(>|<)``
-  Denotes if ``function_name`` has more instructions or fewer instructions in
-  the second file.
-
-  *  ``>``: More instructions in second file than first file.
-  *  ``<``: Fewer instructions in second file than in first file.
-
-``function_name``
-  The name of the changed function.
-
-``N instrs``
-  Second file instruction count - first file instruction count.
-
-``M stack B``
-  Second file stack byte count - first file stack byte count.
-
-Summary Section
-###############
-
-:program:`llvm-remark-size-diff` will output a high-level summary after
-printing all changed functions.
-
-::
-
-  instruction count: N (inst_pct_change%)
-  stack byte usage: M (sb_pct_change%)
-
-``N``
-  Sum of all instruction count changes between the second and first file.
-
-``inst_pct_change%``
-  Percent increase or decrease in instruction count between the second and first
-  file.
-
-``M``
-  Sum of all stack byte count changes between the second and first file.
-
-``sb_pct_change%``
-  Percent increase or decrease in stack byte usage between the second and first
-  file.
-
-JSON OUTPUT
------------
-
-High-Level view
-###############
-
-Suppose we are comparing two files, OLD and NEW.
-
-:program:`llvm-remark-size-diff` will output JSON as follows.
-
-::
-
-  "Files": [
-    "A": "path/to/OLD",
-    "B": "path/to/NEW"
-  ]
-
-  "InBoth": [
-    ...
-  ],
-
-  "OnlyInA": [
-    ...
-  ],
-
-  "OnlyInB": [
-    ...
-  ]
-
-
-``Files``
-  Original paths to remark files.
-
-  * ``A``: Path to the first file.
-  * ``B``: Path to the second file.
-
-``InBoth``
-  Functions present in both files.
-
-``OnlyInA``
-  Functions only present in the first file.
-
-``OnlyInB``
-  Functions only present in the second file.
-
-Function JSON
-#############
-
-The ``InBoth``, ``OnlyInA``, and ``OnlyInB`` sections contain size information
-for each function in the input remark files.
-
-::
-
-  {
-    "FunctionName" : "function_name"
-    "InstCount": [
-        INST_COUNT_A,
-        INST_COUNT_B
-      ],
-    "StackSize": [
-        STACK_BYTES_A,
-        STACK_BYTES_B
-      ],
-  }
-
-``FunctionName``
-  Name of the function.
-
-``InstCount``
-  Instruction counts for the function.
-
-  * ``INST_COUNT_A``: Instruction count in OLD.
-  * ``INST_COUNT_B``: Instruction count in NEW.
-
-``StackSize``
-  Stack byte counts for the function.
-
-  * ``STACK_BYTES_A``: Stack bytes in OLD.
-  *  ``STACK_BYTES_B``: Stack bytes in NEW.
-
-Computing Diffs From Function JSON
-**********************************
-
-Function JSON does not contain the diffs. Tools consuming JSON output from
-:program:`llvm-remark-size-diff` are responsible for computing the diffs
-separately.
-
-**To compute the diffs:**
-
-* Instruction count diff: ``INST_COUNT_B - INST_COUNT_A``
-* Stack byte count diff: ``STACK_BYTES_B - STACK_BYTES_A``
-
-EXIT STATUS
------------
-
-:program:`llvm-remark-size-diff` returns 0 on success, and a non-zero value
-otherwise.

llvm/docs/CommandGuide/llvm-remarkutil.rst

 
 Subcommands
 -----------
 
   * :ref:`bitstream2yaml_subcommand` - Reserialize bitstream remarks to YAML.
   * :ref:`yaml2bitstream_subcommand` - Reserialize YAML remarks to bitstream.
   * :ref:`instruction-count_subcommand` - Output function instruction counts.
   * :ref:`annotation-count_subcommand` - Output remark type count from annotation remarks.
+  * :ref: `size-diff_subcommand` - Compute diff in size remarks.
 
 .. _bitstream2yaml_subcommand:
 
 bitstream2yaml
 ~~~~~~~~~~~~~~
 
 .. program:: llvm-remarkutil bitstream2yaml
 
::
   Function,Count
   foo,123
 
 if `--use-debug-loc` is passed then the CSV will include the source path, line number and column. 
 
 ::
   Source,Function,Count
   path:line:column,foo,3
+
+.. _size-diff_subcommand:
+
+size-diff
+~~~~~~~~~
+.. program:: llvm-remarkutil size-diff
+
+USAGE: :program:`llvm-remarkutil` size-diff [*options*] *file_a* *file_b* **--parser** *parser*
+
+Summary
+^^^^^^^
+
+:program:`llvm-remarkutil size-diff` diffs size `remarks <https://llvm.org/docs/Remarks.html>`_ in two remark files: ``file_a``
+and ``file_b``.
+
+:program:`llvm-remarkutil size-diff` can be used to gain insight into which
+functions were impacted the most by code generation changes.
+
+In most common use-cases ``file_a`` and ``file_b`` will be remarks output by
+compiling a **fixed source** with **differing compilers** or
+**differing optimization settings**.
+
+:program:`llvm-remarkutil size-diff` handles both
+`YAML <https://llvm.org/docs/Remarks.html#yaml-remarks>`_ and
+`bitstream <https://llvm.org/docs/Remarks.html#llvm-bitstream-remarks>`_
+remarks.
+
+OPTIONS
+-------
+
+.. option:: --parser=<yaml|bitstream>
+
+  Select the type of input remark parser. Required.
+  * ``yaml``: The tool will parse YAML remarks.
+  * ``bitstream``: The tool will parse bitstream remarks.
+
+.. option:: --report-style=<human|json>
+
+  Output style.
+  * ``human``: Human-readable textual report. Default option.
+  * ``json``: JSON report.
+
+.. option:: --pretty
+
+  Pretty-print JSON output. Optional.
+
+  If output is not set to JSON, this does nothing.
+
+.. option:: -o=<file>
+
+  Output file for the report. Outputs to stdout by default.
+
+HUMAN-READABLE OUTPUT
+---------------------
+
+The human-readable format for :program:`llvm-remarkutil size-diff` is composed of
+two sections:
+
+* Per-function changes.
+* A high-level summary of all changes.
+
+Changed Function Section
+########################
+
+Suppose you are comparing two remark files OLD and NEW.
+
+For each function with a **changed instruction count** in OLD and NEW,
+:program:`llvm-remarkutil size-diff` will emit a line like below:
+
+::
+
+  (++|--|==) (>|<) function_name, N instrs, M stack B
+
+A breakdown of the format is below:
+
+``(++|--|==)``
+  Which of OLD and NEW the ``function_name`` is present in.
+
+  * ``++``: Only in NEW. ("Added")
+  * ``--``: Only in OLD. ("Removed")
+  * ``==``: In both.
+
+``(>|<)``
+  Denotes if ``function_name`` has more instructions or fewer instructions in
+  the second file.
+
+  *  ``>``: More instructions in second file than first file.
+  *  ``<``: Fewer instructions in second file than in first file.
+
+``function_name``
+  The name of the changed function.
+
+``N instrs``
+  Second file instruction count - first file instruction count.
+
+``M stack B``
+  Second file stack byte count - first file stack byte count.
+
+Summary Section
+###############
+
+:program:`llvm-remarkutil size-diff` will output a high-level summary after
+printing all changed functions.
+
+::
+
+  instruction count: N (inst_pct_change%)
+  stack byte usage: M (sb_pct_change%)
+
+``N``
+  Sum of all instruction count changes between the second and first file.
+
+``inst_pct_change%``
+  Percent increase or decrease in instruction count between the second and first
+  file.
+
+``M``
+  Sum of all stack byte count changes between the second and first file.
+
+``sb_pct_change%``
+  Percent increase or decrease in stack byte usage between the second and first
+  file.
+
+JSON OUTPUT
+-----------
+
+High-Level view
+###############
+
+Suppose we are comparing two files, OLD and NEW.
+
+:program:`llvm-remarkutil size-diff` will output JSON as follows.
+
+::
+
+  "Files": [
+    "A": "path/to/OLD",
+    "B": "path/to/NEW"
+  ]
+
+  "InBoth": [
+    ...
+  ],
+
+  "OnlyInA": [
+    ...
+  ],
+
+  "OnlyInB": [
+    ...
+  ]
+
+
+``Files``
+  Original paths to remark files.
+
+  * ``A``: Path to the first file.
+  * ``B``: Path to the second file.
+
+``InBoth``
+  Functions present in both files.
+
+``OnlyInA``
+  Functions only present in the first file.
+
+``OnlyInB``
+  Functions only present in the second file.
+
+Function JSON
+#############
+
+The ``InBoth``, ``OnlyInA``, and ``OnlyInB`` sections contain size information
+for each function in the input remark files.
+
+::
+
+  {
+    "FunctionName" : "function_name"
+    "InstCount": [
+        INST_COUNT_A,
+        INST_COUNT_B
+      ],
+    "StackSize": [
+        STACK_BYTES_A,
+        STACK_BYTES_B
+      ],
+  }
+
+``FunctionName``
+  Name of the function.
+
+``InstCount``
+  Instruction counts for the function.
+
+  * ``INST_COUNT_A``: Instruction count in OLD.
+  * ``INST_COUNT_B``: Instruction count in NEW.
+
+``StackSize``
+  Stack byte counts for the function.
+
+  * ``STACK_BYTES_A``: Stack bytes in OLD.
+  *  ``STACK_BYTES_B``: Stack bytes in NEW.
+
+Computing Diffs From Function JSON
+**********************************
+
+Function JSON does not contain the diffs. Tools consuming JSON output from
+:program:`llvm-remarkutil size-diff` are responsible for computing the diffs
+separately.
+
+**To compute the diffs:**
+
+* Instruction count diff: ``INST_COUNT_B - INST_COUNT_A``
+* Stack byte count diff: ``STACK_BYTES_B - STACK_BYTES_A``
+
+EXIT STATUS
+-----------
+
+:program:`llvm-remarkutil size-diff` returns 0 on success, and a non-zero value
+otherwise.

llvm/test/CMakeLists.txt

set(LLVM_TEST_DEPENDS
           llvm-pdbutil
           llvm-profdata
           llvm-profgen
           llvm-ranlib
           llvm-rc
           llvm-readobj
           llvm-readelf
           llvm-reduce
-          llvm-remark-size-diff
           llvm-remarkutil
           llvm-rtdyld
           llvm-sim
           llvm-size
           llvm-split
           llvm-stress
           llvm-strings
           llvm-strip

llvm/test/lit.cfg.py

[
         "llvm-otool",
         "llvm-pdbutil",
         "llvm-profdata",
         "llvm-profgen",
         "llvm-ranlib",
         "llvm-rc",
         "llvm-readelf",
         "llvm-readobj",
-        "llvm-remark-size-diff",
         "llvm-rtdyld",
         "llvm-sim",
         "llvm-size",
         "llvm-split",
         "llvm-stress",
         "llvm-strings",
         "llvm-strip",
         "llvm-tblgen",

llvm/test/tools/llvm-remark-size-diff/empty-file.test

-RUN: not llvm-remark-size-diff %p/Inputs/empty-file.yaml %p/Inputs/1-func-2-instr-2-stack.yaml --parser=yaml 2>&1 | FileCheck %s
-RUN: not llvm-remark-size-diff %p/Inputs/1-func-2-instr-2-stack.yaml %p/Inputs/empty-file.yaml --parser=yaml 2>&1 | FileCheck %s
-
-; CHECK: error: document root is not of mapping type.

llvm/test/tools/llvm-remark-size-diff/inconvertible-integer.test

-RUN: not llvm-remark-size-diff %p/Inputs/inconvertible-integer.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml 2>&1 | FileCheck %s
-
-; CHECK: Could not convert string to signed integer: a

llvm/test/tools/llvm-remark-size-diff/increase-decrease-inst-count.test

-RUN: llvm-remark-size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/1-func-2-instr-2-stack.yaml --parser=yaml | FileCheck -strict-whitespace %s --check-prefix=INCREASE
-RUN: llvm-remark-size-diff %p/Inputs/1-func-2-instr-2-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml | FileCheck -strict-whitespace %s --check-prefix=DECREASE
-
-; Test a size increase/decrease of one instruction + 1 stack byte.
-
-; INCREASE: == > func0, 1 instrs, 1 stack B
-; INCREASE-DAG: instruction count: 1 (100.00%)
-; INCREASE-NEXT: stack byte usage: 1 (100.00%)
-
-; DECREASE: == < func0, -1 instrs, -1 stack B
-; DECREASE-DAG: instruction count: -1 (-50.00%)
-; DECREASE-NEXT: stack byte usage: -1 (-50.00%)

llvm/test/tools/llvm-remark-size-diff/no-difference.test

-RUN: llvm-remark-size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml | FileCheck -strict-whitespace %s
-
-; Same file passed twice -> no changes reported.
-
-; CHECK-NOT: {{[0-9]+}}
-; CHECK: instruction count: None
-; CHECK: stack byte usage: None

llvm/test/tools/llvm-remark-size-diff/no-instruction-count-remarks.test

-RUN: not llvm-remark-size-diff %p/Inputs/no-instruction-count-remarks.yaml %p/Inputs/no-instruction-count-remarks.yaml --parser=yaml 2>&1 | FileCheck %s
-
-; CHECK: error: File {{.*}} did not contain any instruction-count remarks!

llvm/test/tools/llvm-remark-size-diff/unexpected-key.test

-RUN: not llvm-remark-size-diff %p/Inputs/unexpected-key.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml 2>&1 | FileCheck %s
-
-; CHECK: Expected 'NumInstructions', got 'Wrong'

llvm/test/tools/llvm-remarkutil/size-diff/Inputs/1-func-1-instr-1-stack.yaml

 --- !Analysis
 Pass:            prologepilog
 Name:            StackSize
 Function:        func0
 Args:
   - NumStackBytes:   '1'
   - String:          ' stack bytes in function'
 ...
 --- !Analysis
 Pass:            asm-printer
 Name:            InstructionCount
 Function:        func0
 Args:
   - NumInstructions: '1'
   - String:          ' instructions in function'
 ...

llvm/test/tools/llvm-remarkutil/size-diff/Inputs/1-func-2-instr-2-stack.yaml

 --- !Analysis
 Pass:            prologepilog
 Name:            StackSize
 Function:        func0
 Args:
   - NumStackBytes:   '2'
   - String:          ' stack bytes in function'
 ...
 --- !Analysis
 Pass:            asm-printer
 Name:            InstructionCount
 Function:        func0
 Args:
   - NumInstructions: '2'
   - String:          ' instructions in function'
 ...

llvm/test/tools/llvm-remarkutil/size-diff/Inputs/2-identical-func-1-instr-1-stack.yaml

 --- !Analysis
 Pass:            prologepilog
 Name:            StackSize
 Function:        func0
 Args:
   - NumStackBytes:   '1'
   - String:          ' stack bytes in function'
 ...
 --- !Analysis
 Pass:            asm-printer
 Name:            InstructionCount
 Function:        func0
 Args:
   - NumInstructions: '1'
   - String:          ' instructions in function'
 ...
 --- !Analysis
 Pass:            prologepilog
 Name:            StackSize
 Function:        func1
 Args:
   - NumStackBytes:   '1'
   - String:          ' stack bytes in function'
 ...
 --- !Analysis
 Pass:            asm-printer
 Name:            InstructionCount
 Function:        func1
 Args:
   - NumInstructions: '1'
   - String:          ' instructions in function'
 ...

llvm/test/tools/llvm-remarkutil/size-diff/Inputs/inconvertible-integer.yaml

 --- !Analysis
 Pass:            prologepilog
 Name:            StackSize
 Function:        func0
 Args:
   - NumStackBytes:   '1'
   - String:          ' stack bytes in function'
 ...
 --- !Analysis
 Pass:            asm-printer
 Name:            InstructionCount
 Function:        func0
 Args:
   - NumInstructions: 'a'
   - String:          ' instructions in function'
 ...

llvm/test/tools/llvm-remarkutil/size-diff/Inputs/no-instruction-count-remarks.yaml

 --- !Analysis
 Pass:            prologepilog
 Name:            StackSize
 Function:        func0
 Args:
   - NumStackBytes:   '1'
   - String:          ' stack bytes in function'
 ...

llvm/test/tools/llvm-remarkutil/size-diff/Inputs/unexpected-key.yaml

 --- !Analysis
 Pass:            prologepilog
 Name:            StackSize
 Function:        func0
 Args:
   - NumStackBytes:   '1'
   - String:          ' stack bytes in function'
 ...
 --- !Analysis
 Pass:            asm-printer
 Name:            InstructionCount
 Function:        func0
 Args:
   - Wrong: '1'
   - String:          ' instructions in function'
 ...

llvm/test/tools/llvm-remarkutil/size-diff/add-remove-func.test

-RUN: llvm-remark-size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/2-identical-func-1-instr-1-stack.yaml --parser=yaml | FileCheck -strict-whitespace %s --check-prefix=ADD
-RUN: llvm-remark-size-diff %p/Inputs/2-identical-func-1-instr-1-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml  --parser=yaml | FileCheck -strict-whitespace %s --check-prefix=REMOVE
+RUN: llvm-remarkutil size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/2-identical-func-1-instr-1-stack.yaml --parser=yaml | FileCheck -strict-whitespace %s --check-prefix=ADD
+RUN: llvm-remarkutil size-diff %p/Inputs/2-identical-func-1-instr-1-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml  --parser=yaml | FileCheck -strict-whitespace %s --check-prefix=REMOVE
 
 ; The "two-identical-one-instr-funcs" file contains a single-instruction
 ; function which does not appear in the other file.
 
 ; ADD: ++ > func1, 1 instrs, 1 stack B
 ; ADD-DAG: instruction count: 1 (100.00%)
 ; ADD-DAG: stack byte usage: 1 (100.00%)
 
 ; REMOVE: -- < func1, -1 instrs, -1 stack B
 ; REMOVE-DAG: instruction count: -1 (-50.00%)
 ; REMOVE-DAG: stack byte usage: -1 (-50.00%)

llvm/test/tools/llvm-remarkutil/size-diff/empty-file.test

+RUN: not llvm-remarkutil size-diff %p/Inputs/empty-file.yaml %p/Inputs/1-func-2-instr-2-stack.yaml --parser=yaml 2>&1 | FileCheck %s
+RUN: not llvm-remarkutil size-diff %p/Inputs/1-func-2-instr-2-stack.yaml %p/Inputs/empty-file.yaml --parser=yaml 2>&1 | FileCheck %s
+
+; CHECK: error: document root is not of mapping type.

llvm/test/tools/llvm-remarkutil/size-diff/inconvertible-integer.test

+RUN: not llvm-remarkutil size-diff %p/Inputs/inconvertible-integer.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml 2>&1 | FileCheck %s
+
+; CHECK: Could not convert string to signed integer: a

llvm/test/tools/llvm-remarkutil/size-diff/increase-decrease-inst-count.test

+RUN: llvm-remarkutil size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/1-func-2-instr-2-stack.yaml --parser=yaml | FileCheck -strict-whitespace %s --check-prefix=INCREASE
+RUN: llvm-remarkutil size-diff %p/Inputs/1-func-2-instr-2-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml | FileCheck -strict-whitespace %s --check-prefix=DECREASE
+
+; Test a size increase/decrease of one instruction + 1 stack byte.
+
+; INCREASE: == > func0, 1 instrs, 1 stack B
+; INCREASE-DAG: instruction count: 1 (100.00%)
+; INCREASE-NEXT: stack byte usage: 1 (100.00%)
+
+; DECREASE: == < func0, -1 instrs, -1 stack B
+; DECREASE-DAG: instruction count: -1 (-50.00%)
+; DECREASE-NEXT: stack byte usage: -1 (-50.00%)

llvm/test/tools/llvm-remarkutil/size-diff/json-add-remove-func.test

-RUN: llvm-remark-size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/2-identical-func-1-instr-1-stack.yaml --parser=yaml --report_style=json --pretty | FileCheck -strict-whitespace %s --check-prefix=ADD
-RUN: llvm-remark-size-diff %p/Inputs/2-identical-func-1-instr-1-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml  --parser=yaml --report_style=json --pretty | FileCheck -strict-whitespace %s --check-prefix=REMOVE
+RUN: llvm-remarkutil size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/2-identical-func-1-instr-1-stack.yaml --parser=yaml --report_style=json --pretty | FileCheck -strict-whitespace %s --check-prefix=ADD
+RUN: llvm-remarkutil size-diff %p/Inputs/2-identical-func-1-instr-1-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml  --parser=yaml --report_style=json --pretty | FileCheck -strict-whitespace %s --check-prefix=REMOVE
 
 ; The "two-identical-one-instr-funcs" file contains a single-instruction
 ; function which does not appear in the other file.
 
 ; ADD-LABEL: "Files":
 ; ADD: "A":{{.*}}1-func-1-instr-1-stack.yaml
 ; ADD-NEXT: "B":{{.*}}2-identical-func-1-instr-1-stack.yaml
 

llvm/test/tools/llvm-remarkutil/size-diff/json-increase-decrease-inst-count.test

-RUN: llvm-remark-size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/1-func-2-instr-2-stack.yaml --parser=yaml  --report_style=json --pretty | FileCheck -strict-whitespace %s --check-prefix=INCREASE
-RUN: llvm-remark-size-diff %p/Inputs/1-func-2-instr-2-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml  --report_style=json --pretty | FileCheck -strict-whitespace %s --check-prefix=DECREASE
+RUN: llvm-remarkutil size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/1-func-2-instr-2-stack.yaml --parser=yaml  --report_style=json --pretty | FileCheck -strict-whitespace %s --check-prefix=INCREASE
+RUN: llvm-remarkutil size-diff %p/Inputs/1-func-2-instr-2-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml  --report_style=json --pretty | FileCheck -strict-whitespace %s --check-prefix=DECREASE
 
 ; Test a size increase/decrease of one instruction + 1 stack byte.
 
 ; INCREASE-LABEL: "Files":
 ; INCREASE: "A":{{.*}}1-func-1-instr-1-stack.yaml
 ; INCREASE-NEXT: "B":{{.*}}1-func-2-instr-2-stack.yaml
 
 ; INCREASE-LABEL: "InBoth": [

llvm/test/tools/llvm-remarkutil/size-diff/json-no-difference.test

-RUN: llvm-remark-size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml --report_style=json --pretty | FileCheck -strict-whitespace %s
+RUN: llvm-remarkutil size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml --report_style=json --pretty | FileCheck -strict-whitespace %s
 
 ; CHECK-LABEL: "Files":
 ; CHECK: "A":{{.*}}1-func-1-instr-1-stack.yaml
 ; CHECK-NEXT: "B":{{.*}}1-func-1-instr-1-stack.yaml
 
 ; CHECK-LABEL: "InBoth":
 ; CHECK: "FunctionName": "func0",
 ; CHECK-NEXT: "InstCount":

llvm/test/tools/llvm-remarkutil/size-diff/no-difference.test

+RUN: llvm-remarkutil size-diff %p/Inputs/1-func-1-instr-1-stack.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml | FileCheck -strict-whitespace %s
+
+; Same file passed twice -> no changes reported.
+
+; CHECK-NOT: {{[0-9]+}}
+; CHECK: instruction count: None
+; CHECK: stack byte usage: None

llvm/test/tools/llvm-remarkutil/size-diff/no-instruction-count-remarks.test

+RUN: not llvm-remarkutil size-diff %p/Inputs/no-instruction-count-remarks.yaml %p/Inputs/no-instruction-count-remarks.yaml --parser=yaml 2>&1 | FileCheck %s
+
+; CHECK: error: File {{.*}} did not contain any instruction-count remarks!

llvm/test/tools/llvm-remarkutil/size-diff/unexpected-key.test

+RUN: not llvm-remarkutil size-diff %p/Inputs/unexpected-key.yaml %p/Inputs/1-func-1-instr-1-stack.yaml --parser=yaml 2>&1 | FileCheck %s
+
+; CHECK: Expected 'NumInstructions', got 'Wrong'

llvm/tools/llvm-remark-size-diff/CMakeLists.txt

-set(LLVM_LINK_COMPONENTS
-  Demangle
-  Remarks
-  Support
-  )
-
-add_llvm_tool(llvm-remark-size-diff
-  RemarkSizeDiff.cpp
-  )

llvm/tools/llvm-remarkutil/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Demangle
   Remarks
   Support
   )
 
 add_llvm_tool(llvm-remarkutil
   RemarkConvert.cpp
   RemarkCount.cpp
+  RemarkSizeDiff.cpp
   RemarkUtil.cpp
   RemarkUtilHelpers.cpp
   RemarkUtilRegistry.cpp
   )

llvm/tools/llvm-remarkutil/RemarkSizeDiff.cpp

-//===-------------- llvm-remark-size-diff/RemarkSizeDiff.cpp --------------===//
+//===-------------- RemarkSizeDiff.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Diffs instruction count and stack size remarks between two remark files.
 ///
 /// This is intended for use by compiler developers who want to see how their
 /// changes impact program code size.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "llvm-c/Remarks.h"
-#include "llvm/ADT/STLExtras.h"
+#include "RemarkUtilHelpers.h"
+#include "RemarkUtilRegistry.h"
 #include "llvm/ADT/SmallSet.h"
-#include "llvm/Remarks/Remark.h"
-#include "llvm/Remarks/RemarkParser.h"
-#include "llvm/Remarks/RemarkSerializer.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/JSON.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/ToolOutputFile.h"
-#include "llvm/Support/WithColor.h"
-#include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
-
-enum ParserFormatOptions { yaml, bitstream };
+using namespace remarks;
+using namespace remarkutil;
+static cl::SubCommand
+    RemarkSizeDiffUtil("size-diff",
+                       "Diff instruction count and stack size remarks "
+                       "between two remark files");
 enum ReportStyleOptions { human_output, json_output };
-static cl::OptionCategory SizeDiffCategory("llvm-remark-size-diff options");
 static cl::opt<std::string> InputFileNameA(cl::Positional, cl::Required,
-                                           cl::cat(SizeDiffCategory),
+                                           cl::sub(RemarkSizeDiffUtil),
                                            cl::desc("remarks_a"));
 static cl::opt<std::string> InputFileNameB(cl::Positional, cl::Required,
-                                           cl::cat(SizeDiffCategory),
+                                           cl::sub(RemarkSizeDiffUtil),
                                            cl::desc("remarks_b"));
 static cl::opt<std::string> OutputFilename("o", cl::init("-"),
-                                           cl::cat(SizeDiffCategory),
+                                           cl::sub(RemarkSizeDiffUtil),
                                            cl::desc("Output"),
                                            cl::value_desc("file"));
-static cl::opt<ParserFormatOptions>
-    ParserFormat("parser", cl::cat(SizeDiffCategory), cl::init(bitstream),
-                 cl::desc("Set the remark parser format:"),
-                 cl::values(clEnumVal(yaml, "YAML format"),
-                            clEnumVal(bitstream, "Bitstream format")));
+INPUT_FORMAT_COMMAND_LINE_OPTIONS(RemarkSizeDiffUtil)
 static cl::opt<ReportStyleOptions> ReportStyle(
-    "report_style", cl::cat(SizeDiffCategory),
+    "report_style", cl::sub(RemarkSizeDiffUtil),
     cl::init(ReportStyleOptions::human_output),
     cl::desc("Choose the report output format:"),
     cl::values(clEnumValN(human_output, "human", "Human-readable format"),
                clEnumValN(json_output, "json", "JSON format")));
-static cl::opt<bool> PrettyPrint("pretty", cl::cat(SizeDiffCategory),
+static cl::opt<bool> PrettyPrint("pretty", cl::sub(RemarkSizeDiffUtil),
                                  cl::init(false),
                                  cl::desc("Pretty-print JSON"));
 
 /// Contains information from size remarks.
 // This is a little nicer to read than a std::pair.
 struct InstCountAndStackSize {
   int64_t InstCount = 0;
   int64_t StackSize = 0;

 /// Process all of the size-related remarks in a file.
 ///
 /// \param[in] InputFileName - Name of file to read from.
 /// \param[in, out] FuncNameToSizeInfo - Maps function names to relevant
 /// size info.
 static Error readFileAndProcessRemarks(
     StringRef InputFileName,
     StringMap<InstCountAndStackSize> &FuncNameToSizeInfo) {
-  auto Buf = MemoryBuffer::getFile(InputFileName);
-  if (auto EC = Buf.getError())
-    return createStringError(
-        EC, Twine("Cannot open file '" + InputFileName + "': " + EC.message()));
-  auto MaybeParser = remarks::createRemarkParserFromMeta(
-      ParserFormat == bitstream ? remarks::Format::Bitstream
-                                : remarks::Format::YAML,
-      (*Buf)->getBuffer());
+
+  auto MaybeBuf = getInputMemoryBuffer(InputFileName);
+  if (!MaybeBuf)
+    return MaybeBuf.takeError();
+  auto MaybeParser =
+      createRemarkParserFromMeta(InputFormat, (*MaybeBuf)->getBuffer());
   if (!MaybeParser)
     return MaybeParser.takeError();
   auto &Parser = **MaybeParser;
   auto MaybeRemark = Parser.next();
   unsigned NumInstCountRemarksParsed = 0;
   for (; MaybeRemark; MaybeRemark = Parser.next()) {
     if (auto E = processRemark(**MaybeRemark, FuncNameToSizeInfo,
                                NumInstCountRemarksParsed))

 /// Wrapper function for readFileAndProcessRemarks which handles errors.
 ///
 /// \param[in] InputFileName - Name of file to read from.
 /// \param[out] FuncNameToSizeInfo - Populated with information from size
 /// remarks in the input file.
 ///
 /// \returns true if readFileAndProcessRemarks returned no errors. False
 /// otherwise.
-static bool tryReadFileAndProcessRemarks(
+static Error tryReadFileAndProcessRemarks(
     StringRef InputFileName,
     StringMap<InstCountAndStackSize> &FuncNameToSizeInfo) {
   if (Error E = readFileAndProcessRemarks(InputFileName, FuncNameToSizeInfo)) {
-    handleAllErrors(std::move(E), [&](const ErrorInfoBase &PE) {
-      PE.log(WithColor::error());
-      errs() << '\n';
-    });
-    return false;
+    return E;
   }
-  return true;
+  return Error::success();
 }
 
 /// Populates \p FuncDiffs with the difference between \p
 /// FuncNameToSizeInfoA and \p FuncNameToSizeInfoB.
 ///
 /// \param[in] FuncNameToSizeInfoA - Size info collected from the first
 /// remarks file.
 /// \param[in] FuncNameToSizeInfoB - Size info collected from
outputJSONForAllDiffs(InputFileNameA, InputFileNameB, DiffsByFilesPresent,
                           OF->os());
     break;
   }
   OF->keep();
   return Error::success();
 }
 
 /// Boolean wrapper for outputDiff which handles errors.
-static bool
+static Error
 tryOutputAllDiffs(StringRef InputFileNameA, StringRef InputFileNameB,
                   DiffsCategorizedByFilesPresent &DiffsByFilesPresent) {
   if (Error E =
           outputAllDiffs(InputFileNameA, InputFileNameB, DiffsByFilesPresent)) {
-    handleAllErrors(std::move(E), [&](const ErrorInfoBase &PE) {
-      PE.log(WithColor::error());
-      errs() << '\n';
-    });
-    return false;
+    return E;
   }
-  return true;
+  return Error::success();
 }
 
-int main(int argc, const char **argv) {
-  InitLLVM X(argc, argv);
-  cl::HideUnrelatedOptions(SizeDiffCategory);
-  cl::ParseCommandLineOptions(argc, argv,
-                              "Diff instruction count and stack size remarks "
-                              "between two remark files.\n");
+static Error trySizeSiff() {
   StringMap<InstCountAndStackSize> FuncNameToSizeInfoA;
   StringMap<InstCountAndStackSize> FuncNameToSizeInfoB;
-  if (!tryReadFileAndProcessRemarks(InputFileNameA, FuncNameToSizeInfoA) ||
-      !tryReadFileAndProcessRemarks(InputFileNameB, FuncNameToSizeInfoB))
-    return 1;
+  if (auto E =
+          tryReadFileAndProcessRemarks(InputFileNameA, FuncNameToSizeInfoA))
+    return E;
+  if (auto E =
+          tryReadFileAndProcessRemarks(InputFileNameB, FuncNameToSizeInfoB))
+    return E;
   DiffsCategorizedByFilesPresent DiffsByFilesPresent;
   computeDiff(FuncNameToSizeInfoA, FuncNameToSizeInfoB, DiffsByFilesPresent);
-  if (!tryOutputAllDiffs(InputFileNameA, InputFileNameB, DiffsByFilesPresent))
-    return 1;
+  if (auto E = tryOutputAllDiffs(InputFileNameA, InputFileNameB,
+                                 DiffsByFilesPresent))
+    return E;
+  return Error::success();
 }
+
+static CommandRegistration RemarkSizeSiffRegister(&RemarkSizeDiffUtil,
+                                                  trySizeSiff);
 No newline at end of file

llvm/utils/gn/secondary/llvm/test/BUILD.gn

deps = [
     "//llvm/tools/llvm-opt-fuzzer",
     "//llvm/tools/llvm-opt-report",
     "//llvm/tools/llvm-pdbutil",
     "//llvm/tools/llvm-profdata",
     "//llvm/tools/llvm-profgen",
     "//llvm/tools/llvm-rc:symlinks",
     "//llvm/tools/llvm-readobj:symlinks",
     "//llvm/tools/llvm-reduce",
-    "//llvm/tools/llvm-remark-size-diff",
     "//llvm/tools/llvm-remarkutil",
     "//llvm/tools/llvm-rtdyld",
     "//llvm/tools/llvm-sim",
     "//llvm/tools/llvm-size",
     "//llvm/tools/llvm-split",
     "//llvm/tools/llvm-stress",
     "//llvm/tools/llvm-strings",
     "//llvm/tools/llvm-symbolizer:symlinks",

llvm/utils/gn/secondary/llvm/tools/llvm-remark-size-diff/BUILD.gn

-executable("llvm-remark-size-diff") {
-  deps = [
-    "//llvm/lib/Demangle",
-    "//llvm/lib/IR",
-    "//llvm/lib/Object",
-    "//llvm/lib/Remarks",
-    "//llvm/lib/Support",
-  ]
-  sources = [ "RemarkSizeDiff.cpp" ]
-}

utils/bazel/llvm-project-overlay/llvm/BUILD.bazel

deps = [
         ":Support",
         ":Target",
         ":TargetParser",
         ":TransformUtils",
     ],
 )
 
 cc_binary(
-    name = "llvm-remark-size-diff",
-    srcs = glob([
-        "tools/llvm-remark-size-diff/**/*.cpp",
-        "tools/llvm-remark-size-diff/**/*.h",
-    ]),
-    copts = llvm_copts,
-    includes = ["tools/llvm-reark-size-diff"],
-    stamp = 0,
-    deps = [
-        ":Core",
-        ":Demangle",
-        ":Object",
-        ":Remarks",
-        ":Support",
-    ],
-)
-
-cc_binary(
     name = "llvm-rtdyld",
     srcs = glob([
         "tools/llvm-rtdyld/*.cpp",
         "tools/llvm-rtdyld/*.h",
     ]),
     copts = llvm_copts,
     stamp = 0,
     deps = [