| |
| #!/usr/bin/env python |
| |
| # Auto-generates an exhaustive and repetitive test for correct bundle-locked |
| # alignment on x86. |
| # For every possible offset in an aligned bundle, a bundle-locked group of every |
| # size in the inclusive range [1, bundle_size] is inserted. An appropriate CHECK |
| # is added to verify that NOP padding occurred (or did not occur) as expected. |
| # Run with --align-to-end to generate a similar test with align_to_end for each |
| # .bundle_lock directive. |
| |
| # This script runs with Python 2.7 and 3.2+ |
| |
| from __future__ import print_function |
| import argparse |
| |
| BUNDLE_SIZE_POW2 = 4 |
| BUNDLE_SIZE = 2 ** BUNDLE_SIZE_POW2 |
| |
| PREAMBLE = ''' |
| # RUN: llvm-mc -filetype=obj -triple i386-pc-linux-gnu %s -o - \\ |
| # RUN: | llvm-objdump -triple i386 -disassemble -no-show-raw-insn - | FileCheck %s |
| |
| # !!! This test is auto-generated from utils/testgen/mc-bundling-x86-gen.py !!! |
| # It tests that bundle-aligned grouping works correctly in MC. Read the |
| # source of the script for more details. |
| |
| .text |
| .bundle_align_mode {0} |
| '''.format(BUNDLE_SIZE_POW2).lstrip() |
| |
| ALIGNTO = ' .align {0}, 0x90' |
| NOPFILL = ' .fill {0}, 1, 0x90' |
| |
| def print_bundle_locked_sequence(len, align_to_end=False): |
| print(' .bundle_lock{0}'.format(' align_to_end' if align_to_end else '')) |
| print(' .rept {0}'.format(len)) |
| print(' inc %eax') |
| print(' .endr') |
| print(' .bundle_unlock') |
| |
| def generate(align_to_end=False): |
| print(PREAMBLE) |
| |
| ntest = 0 |
| for instlen in range(1, BUNDLE_SIZE + 1): |
| for offset in range(0, BUNDLE_SIZE): |
| # Spread out all the instructions to not worry about cross-bundle |
| # interference. |
| print(ALIGNTO.format(2 * BUNDLE_SIZE)) |
| print('INSTRLEN_{0}_OFFSET_{1}:'.format(instlen, offset)) |
| if offset > 0: |
| print(NOPFILL.format(offset)) |
| print_bundle_locked_sequence(instlen, align_to_end) |
| |
| # Now generate an appropriate CHECK line |
| base_offset = ntest * 2 * BUNDLE_SIZE |
| inst_orig_offset = base_offset + offset # had it not been padded... |
| |
| def print_check(adjusted_offset=None, nop_split_offset=None): |
| if adjusted_offset is not None: |
| print('# CHECK: {0:x}: nop'.format(inst_orig_offset)) |
| if nop_split_offset is not None: |
| print('# CHECK: {0:x}: nop'.format(nop_split_offset)) |
| print('# CHECK: {0:x}: incl'.format(adjusted_offset)) |
| else: |
| print('# CHECK: {0:x}: incl'.format(inst_orig_offset)) |
| |
| if align_to_end: |
| if offset + instlen == BUNDLE_SIZE: |
| # No padding needed |
| print_check() |
| elif offset + instlen < BUNDLE_SIZE: |
| # Pad to end at nearest bundle boundary |
| offset_to_end = base_offset + (BUNDLE_SIZE - instlen) |
| print_check(offset_to_end) |
| else: # offset + instlen > BUNDLE_SIZE |
| # Pad to end at next bundle boundary, splitting the nop sequence |
| # at the nearest bundle boundary |
| offset_to_nearest_bundle = base_offset + BUNDLE_SIZE |
| offset_to_end = base_offset + (BUNDLE_SIZE * 2 - instlen) |
| if offset_to_nearest_bundle == offset_to_end: |
| offset_to_nearest_bundle = None |
| print_check(offset_to_end, offset_to_nearest_bundle) |
| else: |
| if offset + instlen > BUNDLE_SIZE: |
| # Padding needed |
| aligned_offset = (inst_orig_offset + instlen) & ~(BUNDLE_SIZE - 1) |
| print_check(aligned_offset) |
| else: |
| # No padding needed |
| print_check() |
| |
| print() |
| ntest += 1 |
| |
| if __name__ == '__main__': |
| argparser = argparse.ArgumentParser() |
| argparser.add_argument('--align-to-end', |
| action='store_true', |
| help='generate .bundle_lock with align_to_end option') |
| args = argparser.parse_args() |
| generate(align_to_end=args.align_to_end) |