UpdateTestChecks: fix AMDGPU handling
Summary:
Was looking into supporting `(srl (shl x, c1), c2)` with c1 != c2 in dagcombiner,
this test changes, but makes `update_llc_test_checks.py` unhappy.
**Many** AMDGPU tests specify `-march`, not `-mtriple`, which results in `update_llc_test_checks.py`
defaulting to x86 asm function detection heuristics, which don't work here.
I propose to fix this by adding an infrastructure to map from `-march` to `-mtriple`,
in the UpdateTestChecks tooling.
Reviewers: RKSimon, MaskRay, arsenm
Reviewed By: arsenm
Subscribers: kzhuravl, jvesely, wdng, nhaehnle, yaxunl, dstuttard, tpr, t-tye, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D62099
llvm-svn: 361101
2019-05-18 21:00:03 +08:00
|
|
|
from __future__ import print_function
|
2018-01-30 08:40:05 +08:00
|
|
|
import re
|
2018-02-10 13:01:33 +08:00
|
|
|
import sys
|
2018-01-30 08:40:05 +08:00
|
|
|
|
|
|
|
|
from . import common
|
|
|
|
|
|
2018-02-10 13:01:33 +08:00
|
|
|
if sys.version_info[0] > 2:
|
|
|
|
|
class string:
|
|
|
|
|
expandtabs = str.expandtabs
|
|
|
|
|
else:
|
|
|
|
|
import string
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
# RegEx: this is where the magic happens.
|
|
|
|
|
|
2018-02-10 13:01:33 +08:00
|
|
|
##### Assembly parser
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
ASM_FUNCTION_X86_RE = re.compile(
|
2020-12-31 03:59:36 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*(@"?(?P=func)"?| -- Begin function (?P=func))\n(?:\s*\.?Lfunc_begin[^:\n]*:\n)?'
|
|
|
|
|
r'(?:\.L[^$]+\$local:\n)?' # drop .L<func>$local:
|
2020-12-31 04:32:46 +08:00
|
|
|
r'(?:[ \t]+.cfi_startproc\n|.seh_proc[^\n]+\n)?' # drop optional cfi
|
2018-01-30 08:40:05 +08:00
|
|
|
r'(?P<body>^##?[ \t]+[^:]+:.*?)\s*'
|
|
|
|
|
r'^\s*(?:[^:\n]+?:\s*\n\s*\.size|\.cfi_endproc|\.globl|\.comm|\.(?:sub)?section|#+ -- End function)',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
|
|
|
|
ASM_FUNCTION_ARM_RE = re.compile(
|
2022-04-15 23:11:24 +08:00
|
|
|
r'^(?P<func>[0-9a-zA-Z_]+):\n' # f: (name of function)
|
|
|
|
|
r'\s+\.fnstart\n' # .fnstart
|
|
|
|
|
r'(?P<body>.*?)\n' # (body of the function)
|
|
|
|
|
r'.Lfunc_end[0-9]+:', # .Lfunc_end0: or # -- End function
|
|
|
|
|
flags=(re.M | re.S))
|
2018-01-30 08:40:05 +08:00
|
|
|
|
|
|
|
|
ASM_FUNCTION_AARCH64_RE = re.compile(
|
2020-01-14 02:16:35 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*\/\/[ \t]*@"?(?P=func)"?( (Function|Tail Call))?\n'
|
2019-05-24 03:15:05 +08:00
|
|
|
r'(?:[ \t]+.cfi_startproc\n)?' # drop optional cfi noise
|
2018-01-30 08:40:05 +08:00
|
|
|
r'(?P<body>.*?)\n'
|
|
|
|
|
# This list is incomplete
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
[Utils] update_llc_test_checks.py: support AMDGPU backend: AMDGCN, r600 triples
Summary:
Lack of that support has taken me by surprise.
I need to add (or at least look at) some tests for https://reviews.llvm.org/D47980#1127615,
and i don't really fancy doing that by hand.
The asm pattern is quite similar to that of x86:
https://godbolt.org/g/hfgeds
just with `#` replaced with `;`
Reviewers: spatel, RKSimon, MaskRay, tstellar, arsenm
Reviewed By: arsenm
Subscribers: arsenm, kzhuravl, wdng, yaxunl, dstuttard, tpr, t-tye, rampitec, bogner, mareko, llvm-commits
Tags: #amdgpu
Differential Revision: https://reviews.llvm.org/D48001
llvm-svn: 334396
2018-06-11 17:20:21 +08:00
|
|
|
ASM_FUNCTION_AMDGPU_RE = re.compile(
|
2020-01-24 04:30:32 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*;+[ \t]*@"?(?P=func)"?\n[^:]*?'
|
[Utils] update_llc_test_checks.py: support AMDGPU backend: AMDGCN, r600 triples
Summary:
Lack of that support has taken me by surprise.
I need to add (or at least look at) some tests for https://reviews.llvm.org/D47980#1127615,
and i don't really fancy doing that by hand.
The asm pattern is quite similar to that of x86:
https://godbolt.org/g/hfgeds
just with `#` replaced with `;`
Reviewers: spatel, RKSimon, MaskRay, tstellar, arsenm
Reviewed By: arsenm
Subscribers: arsenm, kzhuravl, wdng, yaxunl, dstuttard, tpr, t-tye, rampitec, bogner, mareko, llvm-commits
Tags: #amdgpu
Differential Revision: https://reviews.llvm.org/D48001
llvm-svn: 334396
2018-06-11 17:20:21 +08:00
|
|
|
r'(?P<body>.*?)\n' # (body of the function)
|
|
|
|
|
# This list is incomplete
|
2019-06-15 04:40:15 +08:00
|
|
|
r'^\s*(\.Lfunc_end[0-9]+:\n|\.section)',
|
[Utils] update_llc_test_checks.py: support AMDGPU backend: AMDGCN, r600 triples
Summary:
Lack of that support has taken me by surprise.
I need to add (or at least look at) some tests for https://reviews.llvm.org/D47980#1127615,
and i don't really fancy doing that by hand.
The asm pattern is quite similar to that of x86:
https://godbolt.org/g/hfgeds
just with `#` replaced with `;`
Reviewers: spatel, RKSimon, MaskRay, tstellar, arsenm
Reviewed By: arsenm
Subscribers: arsenm, kzhuravl, wdng, yaxunl, dstuttard, tpr, t-tye, rampitec, bogner, mareko, llvm-commits
Tags: #amdgpu
Differential Revision: https://reviews.llvm.org/D48001
llvm-svn: 334396
2018-06-11 17:20:21 +08:00
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2019-06-05 22:08:01 +08:00
|
|
|
ASM_FUNCTION_HEXAGON_RE = re.compile(
|
2020-01-24 04:30:32 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*//[ \t]*@"?(?P=func)"?\n[^:]*?'
|
2019-06-05 22:08:01 +08:00
|
|
|
r'(?P<body>.*?)\n' # (body of the function)
|
|
|
|
|
# This list is incomplete
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2021-03-08 08:32:37 +08:00
|
|
|
ASM_FUNCTION_M68K_RE = re.compile(
|
|
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*;[ \t]*@"?(?P=func)"?\n'
|
|
|
|
|
r'(?P<body>.*?)\s*' # (body of the function)
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
ASM_FUNCTION_MIPS_RE = re.compile(
|
2020-01-24 04:30:32 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@"?(?P=func)"?\n[^:]*?' # f: (name of func)
|
2021-09-28 22:10:07 +08:00
|
|
|
r'(?:\s*\.?Ltmp[^:\n]*:\n)?[^:]*?' # optional .Ltmp<N> for EH
|
2018-01-30 08:40:05 +08:00
|
|
|
r'(?:^[ \t]+\.(frame|f?mask|set).*?\n)+' # Mips+LLVM standard asm prologue
|
|
|
|
|
r'(?P<body>.*?)\n' # (body of the function)
|
2019-10-31 00:52:16 +08:00
|
|
|
# Mips+LLVM standard asm epilogue
|
|
|
|
|
r'(?:(^[ \t]+\.set[^\n]*?\n)*^[ \t]+\.end.*?\n)'
|
2018-01-30 08:40:05 +08:00
|
|
|
r'(\$|\.L)func_end[0-9]+:\n', # $func_end0: (mips32 - O32) or
|
|
|
|
|
# .Lfunc_end0: (mips64 - NewABI)
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2019-10-03 22:34:28 +08:00
|
|
|
ASM_FUNCTION_MSP430_RE = re.compile(
|
2020-01-24 04:30:32 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*;+[ \t]*@"?(?P=func)"?\n[^:]*?'
|
2019-10-03 22:34:28 +08:00
|
|
|
r'(?P<body>.*?)\n'
|
|
|
|
|
r'(\$|\.L)func_end[0-9]+:\n', # $func_end0:
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2021-01-26 17:50:56 +08:00
|
|
|
ASM_FUNCTION_AVR_RE = re.compile(
|
|
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*;+[ \t]*@"?(?P=func)"?\n[^:]*?'
|
|
|
|
|
r'(?P<body>.*?)\n'
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
ASM_FUNCTION_PPC_RE = re.compile(
|
2021-01-05 10:21:31 +08:00
|
|
|
r'#[ \-\t]*Begin function (?P<func>[^.:]+)\n'
|
2018-10-26 11:30:28 +08:00
|
|
|
r'.*?'
|
2021-01-05 10:21:31 +08:00
|
|
|
r'^[_.]?(?P=func):(?:[ \t]*#+[ \t]*@"?(?P=func)"?)?\n'
|
|
|
|
|
r'(?:^[^#]*\n)*'
|
2018-01-30 08:40:05 +08:00
|
|
|
r'(?P<body>.*?)\n'
|
|
|
|
|
# This list is incomplete
|
2021-01-05 10:21:31 +08:00
|
|
|
r'(?:^[ \t]*(?:\.(?:long|quad|v?byte)[ \t]+[^\n]+)\n)*'
|
|
|
|
|
r'(?:\.Lfunc_end|L\.\.(?P=func))[0-9]+:\n',
|
2018-01-30 08:40:05 +08:00
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
|
|
|
|
ASM_FUNCTION_RISCV_RE = re.compile(
|
2020-01-24 04:30:32 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@"?(?P=func)"?\n'
|
2020-08-25 01:56:02 +08:00
|
|
|
r'(?:\s*\.?L(?P=func)\$local:\n)?' # optional .L<func>$local: due to -fno-semantic-interposition
|
|
|
|
|
r'(?:\s*\.?Lfunc_begin[^:\n]*:\n)?[^:]*?'
|
2018-01-30 08:40:05 +08:00
|
|
|
r'(?P<body>^##?[ \t]+[^:]+:.*?)\s*'
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2019-05-30 04:03:00 +08:00
|
|
|
ASM_FUNCTION_LANAI_RE = re.compile(
|
2020-01-24 04:30:32 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*!+[ \t]*@"?(?P=func)"?\n'
|
2019-05-30 04:03:00 +08:00
|
|
|
r'(?:[ \t]+.cfi_startproc\n)?' # drop optional cfi noise
|
|
|
|
|
r'(?P<body>.*?)\s*'
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2018-04-20 15:59:13 +08:00
|
|
|
ASM_FUNCTION_SPARC_RE = re.compile(
|
2020-01-24 04:30:32 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*!+[ \t]*@"?(?P=func)"?\n'
|
2018-04-20 15:59:13 +08:00
|
|
|
r'(?P<body>.*?)\s*'
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
ASM_FUNCTION_SYSTEMZ_RE = re.compile(
|
2020-01-24 04:30:32 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@"?(?P=func)"?\n'
|
2018-01-30 08:40:05 +08:00
|
|
|
r'[ \t]+.cfi_startproc\n'
|
|
|
|
|
r'(?P<body>.*?)\n'
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
ASM_FUNCTION_AARCH64_DARWIN_RE = re.compile(
|
2022-04-15 23:11:24 +08:00
|
|
|
r'^_(?P<func>[^:]+):[ \t]*;[ \t]@"?(?P=func)"?\n'
|
|
|
|
|
r'([ \t]*.cfi_startproc\n[\s]*)?'
|
|
|
|
|
r'(?P<body>.*?)'
|
|
|
|
|
r'([ \t]*.cfi_endproc\n[\s]*)?'
|
|
|
|
|
r'^[ \t]*;[ \t]--[ \t]End[ \t]function',
|
|
|
|
|
flags=(re.M | re.S))
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
|
2019-06-29 02:07:19 +08:00
|
|
|
ASM_FUNCTION_ARM_DARWIN_RE = re.compile(
|
2022-04-15 23:11:24 +08:00
|
|
|
r'^[ \t]*\.globl[ \t]*_(?P<func>[^ \t])[ \t]*@[ \t]--[ \t]Begin[ \t]function[ \t]"?(?P=func)"?'
|
|
|
|
|
r'(?P<directives>.*?)'
|
|
|
|
|
r'^_(?P=func):\n[ \t]*'
|
|
|
|
|
r'(?P<body>.*?)'
|
|
|
|
|
r'^[ \t]*@[ \t]--[ \t]End[ \t]function',
|
|
|
|
|
flags=(re.M | re.S ))
|
2019-06-29 02:07:19 +08:00
|
|
|
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
ASM_FUNCTION_ARM_MACHO_RE = re.compile(
|
2022-04-15 23:11:24 +08:00
|
|
|
r'^_(?P<func>[^:]+):[ \t]*\n'
|
|
|
|
|
r'([ \t]*.cfi_startproc\n[ \t]*)?'
|
|
|
|
|
r'(?P<body>.*?)\n'
|
|
|
|
|
r'[ \t]*\.cfi_endproc\n',
|
|
|
|
|
flags=(re.M | re.S))
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
|
2021-06-23 21:19:28 +08:00
|
|
|
ASM_FUNCTION_THUMBS_DARWIN_RE = re.compile(
|
2022-04-15 23:11:24 +08:00
|
|
|
r'^_(?P<func>[^:]+):\n'
|
|
|
|
|
r'(?P<body>.*?)\n'
|
|
|
|
|
r'[ \t]*\.data_region\n',
|
|
|
|
|
flags=(re.M | re.S))
|
2021-06-23 20:34:29 +08:00
|
|
|
|
2021-06-23 21:19:28 +08:00
|
|
|
ASM_FUNCTION_THUMB_DARWIN_RE = re.compile(
|
2022-04-15 23:11:24 +08:00
|
|
|
r'^_(?P<func>[^:]+):\n'
|
|
|
|
|
r'(?P<body>.*?)\n'
|
|
|
|
|
r'^[ \t]*@[ \t]--[ \t]End[ \t]function',
|
|
|
|
|
flags=(re.M | re.S))
|
2021-06-23 21:19:28 +08:00
|
|
|
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
ASM_FUNCTION_ARM_IOS_RE = re.compile(
|
2022-04-15 23:11:24 +08:00
|
|
|
r'^_(?P<func>[^:]+):\n'
|
|
|
|
|
r'(?P<body>.*?)'
|
|
|
|
|
r'^[ \t]*@[ \t]--[ \t]End[ \t]function',
|
|
|
|
|
flags=(re.M | re.S))
|
2021-06-23 20:22:02 +08:00
|
|
|
|
2019-05-22 07:06:34 +08:00
|
|
|
ASM_FUNCTION_WASM32_RE = re.compile(
|
2020-01-24 04:30:32 +08:00
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@"?(?P=func)"?\n'
|
2019-05-22 07:06:34 +08:00
|
|
|
r'(?P<body>.*?)\n'
|
2019-08-05 00:28:37 +08:00
|
|
|
r'^\s*(\.Lfunc_end[0-9]+:\n|end_function)',
|
2019-05-22 07:06:34 +08:00
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2021-12-23 21:12:34 +08:00
|
|
|
ASM_FUNCTION_VE_RE = re.compile(
|
|
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@(?P=func)\n'
|
|
|
|
|
r'(?P<body>^##?[ \t]+[^:]+:.*?)\s*'
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2022-01-05 15:55:11 +08:00
|
|
|
ASM_FUNCTION_CSKY_RE = re.compile(
|
|
|
|
|
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@(?P=func)\n(?:\s*\.?Lfunc_begin[^:\n]*:\n)?[^:]*?'
|
|
|
|
|
r'(?P<body>^##?[ \t]+[^:]+:.*?)\s*'
|
|
|
|
|
r'.Lfunc_end[0-9]+:\n',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2022-04-15 15:57:38 +08:00
|
|
|
ASM_FUNCTION_NVPTX_RE = re.compile(
|
|
|
|
|
# function attributes and retval
|
|
|
|
|
# .visible .func (.param .align 16 .b8 func_retval0[32])
|
|
|
|
|
#r'^(\.visible\s+)?\.func\s+(\([^\)]*\)\s*)?'
|
|
|
|
|
r'^(\.(func|visible|weak|entry|noreturn|extern)\s+)+(\([^\)]*\)\s*)?'
|
|
|
|
|
|
|
|
|
|
# function name
|
|
|
|
|
r'(?P<func>[^\(\n]+)'
|
|
|
|
|
|
|
|
|
|
# function name separator (opening brace)
|
|
|
|
|
r'(?P<func_name_separator>\()'
|
|
|
|
|
|
|
|
|
|
# function parameters
|
|
|
|
|
# (
|
|
|
|
|
# .param .align 16 .b8 callee_St8x4_param_0[32]
|
|
|
|
|
# ) // -- Begin function callee_St8x4
|
|
|
|
|
r'[^\)]*\)(\s*//[^\n]*)?\n'
|
|
|
|
|
|
|
|
|
|
# function body
|
|
|
|
|
r'(?P<body>.*?)\n'
|
|
|
|
|
|
|
|
|
|
# function body end marker
|
|
|
|
|
r'\s*// -- End function',
|
|
|
|
|
flags=(re.M | re.S))
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
SCRUB_X86_SHUFFLES_RE = (
|
|
|
|
|
re.compile(
|
|
|
|
|
r'^(\s*\w+) [^#\n]+#+ ((?:[xyz]mm\d+|mem)( \{%k\d+\}( \{z\})?)? = .*)$',
|
|
|
|
|
flags=re.M))
|
2020-02-20 22:22:56 +08:00
|
|
|
|
|
|
|
|
SCRUB_X86_SHUFFLES_NO_MEM_RE = (
|
|
|
|
|
re.compile(
|
|
|
|
|
r'^(\s*\w+) [^#\n]+#+ ((?:[xyz]mm\d+|mem)( \{%k\d+\}( \{z\})?)? = (?!.*(?:mem)).*)$',
|
|
|
|
|
flags=re.M))
|
|
|
|
|
|
2018-04-03 17:57:05 +08:00
|
|
|
SCRUB_X86_SPILL_RELOAD_RE = (
|
|
|
|
|
re.compile(
|
|
|
|
|
r'-?\d+\(%([er])[sb]p\)(.*(?:Spill|Reload))$',
|
|
|
|
|
flags=re.M))
|
2018-01-30 08:40:05 +08:00
|
|
|
SCRUB_X86_SP_RE = re.compile(r'\d+\(%(esp|rsp)\)')
|
|
|
|
|
SCRUB_X86_RIP_RE = re.compile(r'[.\w]+\(%rip\)')
|
2021-05-22 10:26:15 +08:00
|
|
|
SCRUB_X86_LCP_RE = re.compile(r'\.?LCPI[0-9]+_[0-9]+')
|
2018-01-30 08:40:05 +08:00
|
|
|
SCRUB_X86_RET_RE = re.compile(r'ret[l|q]')
|
|
|
|
|
|
|
|
|
|
def scrub_asm_x86(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
2020-02-20 22:22:56 +08:00
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
# Detect shuffle asm comments and hide the operands in favor of the comments.
|
2020-02-20 22:22:56 +08:00
|
|
|
if getattr(args, 'no_x86_scrub_mem_shuffle', True):
|
|
|
|
|
asm = SCRUB_X86_SHUFFLES_NO_MEM_RE.sub(r'\1 {{.*#+}} \2', asm)
|
|
|
|
|
else:
|
|
|
|
|
asm = SCRUB_X86_SHUFFLES_RE.sub(r'\1 {{.*#+}} \2', asm)
|
|
|
|
|
|
2018-04-03 17:57:05 +08:00
|
|
|
# Detect stack spills and reloads and hide their exact offset and whether
|
|
|
|
|
# they used the stack pointer or frame pointer.
|
2018-04-03 18:28:56 +08:00
|
|
|
asm = SCRUB_X86_SPILL_RELOAD_RE.sub(r'{{[-0-9]+}}(%\1{{[sb]}}p)\2', asm)
|
2020-12-13 01:11:13 +08:00
|
|
|
if getattr(args, 'x86_scrub_sp', True):
|
|
|
|
|
# Generically match the stack offset of a memory operand.
|
|
|
|
|
asm = SCRUB_X86_SP_RE.sub(r'{{[0-9]+}}(%\1)', asm)
|
2018-07-24 05:14:35 +08:00
|
|
|
if getattr(args, 'x86_scrub_rip', False):
|
|
|
|
|
# Generically match a RIP-relative memory operand.
|
|
|
|
|
asm = SCRUB_X86_RIP_RE.sub(r'{{.*}}(%rip)', asm)
|
2018-01-30 08:40:05 +08:00
|
|
|
# Generically match a LCP symbol.
|
2021-05-22 10:26:15 +08:00
|
|
|
asm = SCRUB_X86_LCP_RE.sub(r'{{\.?LCPI[0-9]+_[0-9]+}}', asm)
|
2018-06-01 21:37:01 +08:00
|
|
|
if getattr(args, 'extra_scrub', False):
|
2018-01-30 08:40:05 +08:00
|
|
|
# Avoid generating different checks for 32- and 64-bit because of 'retl' vs 'retq'.
|
|
|
|
|
asm = SCRUB_X86_RET_RE.sub(r'ret{{[l|q]}}', asm)
|
|
|
|
|
# Strip kill operands inserted into the asm.
|
|
|
|
|
asm = common.SCRUB_KILL_COMMENT_RE.sub('', asm)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
[Utils] update_llc_test_checks.py: support AMDGPU backend: AMDGCN, r600 triples
Summary:
Lack of that support has taken me by surprise.
I need to add (or at least look at) some tests for https://reviews.llvm.org/D47980#1127615,
and i don't really fancy doing that by hand.
The asm pattern is quite similar to that of x86:
https://godbolt.org/g/hfgeds
just with `#` replaced with `;`
Reviewers: spatel, RKSimon, MaskRay, tstellar, arsenm
Reviewed By: arsenm
Subscribers: arsenm, kzhuravl, wdng, yaxunl, dstuttard, tpr, t-tye, rampitec, bogner, mareko, llvm-commits
Tags: #amdgpu
Differential Revision: https://reviews.llvm.org/D48001
llvm-svn: 334396
2018-06-11 17:20:21 +08:00
|
|
|
def scrub_asm_amdgpu(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
def scrub_asm_arm_eabi(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip kill operands inserted into the asm.
|
|
|
|
|
asm = common.SCRUB_KILL_COMMENT_RE.sub('', asm)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2019-06-05 22:08:01 +08:00
|
|
|
def scrub_asm_hexagon(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2019-05-24 03:54:41 +08:00
|
|
|
def scrub_asm_powerpc(asm, args):
|
2018-01-30 08:40:05 +08:00
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
2020-04-10 23:03:16 +08:00
|
|
|
# Strip unimportant comments, but leave the token '#' in place.
|
2020-04-02 17:46:45 +08:00
|
|
|
asm = common.SCRUB_LOOP_COMMENT_RE.sub(r'#', asm)
|
2018-01-30 08:40:05 +08:00
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
2020-04-10 23:03:16 +08:00
|
|
|
# Strip the tailing token '#', except the line only has token '#'.
|
2020-04-10 14:09:01 +08:00
|
|
|
asm = common.SCRUB_TAILING_COMMENT_TOKEN_RE.sub(r'', asm)
|
2018-01-30 08:40:05 +08:00
|
|
|
return asm
|
|
|
|
|
|
2021-03-08 08:32:37 +08:00
|
|
|
def scrub_asm_m68k(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
def scrub_asm_mips(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2019-10-03 22:34:28 +08:00
|
|
|
def scrub_asm_msp430(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2021-01-26 17:50:56 +08:00
|
|
|
def scrub_asm_avr(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
def scrub_asm_riscv(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2019-05-30 04:03:00 +08:00
|
|
|
def scrub_asm_lanai(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2018-04-20 15:59:13 +08:00
|
|
|
def scrub_asm_sparc(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2018-01-30 08:40:05 +08:00
|
|
|
def scrub_asm_systemz(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2019-05-22 07:06:34 +08:00
|
|
|
def scrub_asm_wasm32(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2021-12-23 21:12:34 +08:00
|
|
|
def scrub_asm_ve(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2022-01-05 15:55:11 +08:00
|
|
|
def scrub_asm_csky(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip kill operands inserted into the asm.
|
|
|
|
|
asm = common.SCRUB_KILL_COMMENT_RE.sub('', asm)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
2022-04-15 15:57:38 +08:00
|
|
|
def scrub_asm_nvptx(asm, args):
|
|
|
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
|
|
|
# whitespace in place.
|
|
|
|
|
asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
|
|
|
|
|
# Expand the tabs used for indentation.
|
|
|
|
|
asm = string.expandtabs(asm, 2)
|
|
|
|
|
# Strip trailing whitespace.
|
|
|
|
|
asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
|
|
|
|
|
return asm
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Returns a tuple of a scrub function and a function regex. Scrub function is
|
|
|
|
|
# used to alter function body in some way, for example, remove traling spaces.
|
|
|
|
|
# Function regex is used to match function name, body, etc. in raw llc output.
|
2020-12-17 02:20:12 +08:00
|
|
|
def get_run_handler(triple):
|
2018-01-30 08:40:05 +08:00
|
|
|
target_handlers = {
|
|
|
|
|
'i686': (scrub_asm_x86, ASM_FUNCTION_X86_RE),
|
|
|
|
|
'x86': (scrub_asm_x86, ASM_FUNCTION_X86_RE),
|
|
|
|
|
'i386': (scrub_asm_x86, ASM_FUNCTION_X86_RE),
|
2021-06-23 20:34:29 +08:00
|
|
|
'arm64_32-apple-ios': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_DARWIN_RE),
|
2018-01-30 08:40:05 +08:00
|
|
|
'aarch64': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_RE),
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
'aarch64-apple-darwin': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_DARWIN_RE),
|
2021-06-23 20:34:29 +08:00
|
|
|
'aarch64-apple-ios': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_DARWIN_RE),
|
2019-06-05 22:08:01 +08:00
|
|
|
'hexagon': (scrub_asm_hexagon, ASM_FUNCTION_HEXAGON_RE),
|
[Utils] update_llc_test_checks.py: support AMDGPU backend: AMDGCN, r600 triples
Summary:
Lack of that support has taken me by surprise.
I need to add (or at least look at) some tests for https://reviews.llvm.org/D47980#1127615,
and i don't really fancy doing that by hand.
The asm pattern is quite similar to that of x86:
https://godbolt.org/g/hfgeds
just with `#` replaced with `;`
Reviewers: spatel, RKSimon, MaskRay, tstellar, arsenm
Reviewed By: arsenm
Subscribers: arsenm, kzhuravl, wdng, yaxunl, dstuttard, tpr, t-tye, rampitec, bogner, mareko, llvm-commits
Tags: #amdgpu
Differential Revision: https://reviews.llvm.org/D48001
llvm-svn: 334396
2018-06-11 17:20:21 +08:00
|
|
|
'r600': (scrub_asm_amdgpu, ASM_FUNCTION_AMDGPU_RE),
|
|
|
|
|
'amdgcn': (scrub_asm_amdgpu, ASM_FUNCTION_AMDGPU_RE),
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
'arm': (scrub_asm_arm_eabi, ASM_FUNCTION_ARM_RE),
|
|
|
|
|
'arm64': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_RE),
|
2020-09-03 23:43:21 +08:00
|
|
|
'arm64e': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_DARWIN_RE),
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
'arm64-apple-ios': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_DARWIN_RE),
|
|
|
|
|
'armv7-apple-ios' : (scrub_asm_arm_eabi, ASM_FUNCTION_ARM_IOS_RE),
|
2019-06-29 02:07:19 +08:00
|
|
|
'armv7-apple-darwin': (scrub_asm_arm_eabi, ASM_FUNCTION_ARM_DARWIN_RE),
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
'thumb': (scrub_asm_arm_eabi, ASM_FUNCTION_ARM_RE),
|
|
|
|
|
'thumb-macho': (scrub_asm_arm_eabi, ASM_FUNCTION_ARM_MACHO_RE),
|
|
|
|
|
'thumbv5-macho': (scrub_asm_arm_eabi, ASM_FUNCTION_ARM_MACHO_RE),
|
2021-06-23 21:19:28 +08:00
|
|
|
'thumbv7s-apple-darwin' : (scrub_asm_arm_eabi, ASM_FUNCTION_THUMBS_DARWIN_RE),
|
|
|
|
|
'thumbv7-apple-darwin' : (scrub_asm_arm_eabi, ASM_FUNCTION_THUMB_DARWIN_RE),
|
2021-06-23 20:28:37 +08:00
|
|
|
'thumbv7-apple-ios' : (scrub_asm_arm_eabi, ASM_FUNCTION_ARM_IOS_RE),
|
2021-03-08 08:32:37 +08:00
|
|
|
'm68k': (scrub_asm_m68k, ASM_FUNCTION_M68K_RE),
|
2018-01-30 08:40:05 +08:00
|
|
|
'mips': (scrub_asm_mips, ASM_FUNCTION_MIPS_RE),
|
2019-10-03 22:34:28 +08:00
|
|
|
'msp430': (scrub_asm_msp430, ASM_FUNCTION_MSP430_RE),
|
2021-01-26 17:50:56 +08:00
|
|
|
'avr': (scrub_asm_avr, ASM_FUNCTION_AVR_RE),
|
2019-05-24 03:54:41 +08:00
|
|
|
'ppc32': (scrub_asm_powerpc, ASM_FUNCTION_PPC_RE),
|
2019-06-25 02:00:34 +08:00
|
|
|
'powerpc': (scrub_asm_powerpc, ASM_FUNCTION_PPC_RE),
|
2018-01-30 08:40:05 +08:00
|
|
|
'riscv32': (scrub_asm_riscv, ASM_FUNCTION_RISCV_RE),
|
|
|
|
|
'riscv64': (scrub_asm_riscv, ASM_FUNCTION_RISCV_RE),
|
2019-05-30 04:03:00 +08:00
|
|
|
'lanai': (scrub_asm_lanai, ASM_FUNCTION_LANAI_RE),
|
2018-04-20 15:59:13 +08:00
|
|
|
'sparc': (scrub_asm_sparc, ASM_FUNCTION_SPARC_RE),
|
2018-01-30 08:40:05 +08:00
|
|
|
's390x': (scrub_asm_systemz, ASM_FUNCTION_SYSTEMZ_RE),
|
2019-05-22 07:06:34 +08:00
|
|
|
'wasm32': (scrub_asm_wasm32, ASM_FUNCTION_WASM32_RE),
|
2021-12-23 21:12:34 +08:00
|
|
|
've': (scrub_asm_ve, ASM_FUNCTION_VE_RE),
|
2022-01-05 15:55:11 +08:00
|
|
|
'csky': (scrub_asm_csky, ASM_FUNCTION_CSKY_RE),
|
2022-04-15 15:57:38 +08:00
|
|
|
'nvptx': (scrub_asm_nvptx, ASM_FUNCTION_NVPTX_RE)
|
2018-01-30 08:40:05 +08:00
|
|
|
}
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
handler = None
|
|
|
|
|
best_prefix = ''
|
2018-01-30 08:40:05 +08:00
|
|
|
for prefix, s in target_handlers.items():
|
[NFC] Improve triple match of scripts that update tests
Summary:
The prior behavior of the triple matcher would stop
in the first matched triple. It was not possible to
create specific matches for sub-sets of a triple
(e.g aarch64-apple-darwin would never be used after
aarch64 was matched).
This patch:
1) Allows that specialized triples take priority,
considering that the string lenght of the triple
indentifies how specialized a triple is. If two
triples of same lenght match, the one matched first
prevails, preserving the old behavior.
2) Remove 20 duplicated triples of arm, thumb,
aarch64 options with same arguments, matching
the common prefix (aarch64, arm, thumb) of them.
3) Creates three new function matching regexes and
five triple options for arm64-apple-ios,
(arm|thumb)-apple-ios and thumb(v5)?-macho
Reviewers: lebedev.ri, RKSimon, MaskRay, gbedwell
Reviewed By: MaskRay
Subscribers: javed.absar, kristof.beyls, llvm-commits, carwil
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63145
llvm-svn: 363656
2019-06-18 18:04:36 +08:00
|
|
|
if triple.startswith(prefix) and len(prefix) > len(best_prefix):
|
|
|
|
|
handler = s
|
|
|
|
|
best_prefix = prefix
|
|
|
|
|
|
|
|
|
|
if handler is None:
|
2018-01-30 08:40:05 +08:00
|
|
|
raise KeyError('Triple %r is not supported' % (triple))
|
|
|
|
|
|
2020-12-17 02:20:12 +08:00
|
|
|
return handler
|
2018-02-10 13:01:33 +08:00
|
|
|
|
|
|
|
|
##### Generator of assembly CHECK lines
|
|
|
|
|
|
2022-03-01 17:54:24 +08:00
|
|
|
def add_checks(output_lines, comment_marker, prefix_list, func_dict,
|
2022-01-31 23:06:08 +08:00
|
|
|
func_name, is_filtered):
|
2018-04-05 17:50:58 +08:00
|
|
|
# Label format is based on ASM string.
|
2022-04-15 15:57:38 +08:00
|
|
|
check_label_format = '{} %s-LABEL: %s%s%s'.format(comment_marker)
|
2020-08-11 02:59:07 +08:00
|
|
|
global_vars_seen_dict = {}
|
2022-01-31 23:06:08 +08:00
|
|
|
common.add_checks(output_lines, comment_marker, prefix_list, func_dict,
|
|
|
|
|
func_name, check_label_format, True, False,
|
|
|
|
|
global_vars_seen_dict, is_filtered = is_filtered)
|