Regular instructions golden file test.

src/trusted/validator_ragel/build.scons

 # -*- python -*-
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import json
 import hashlib
 import os
 import platform
 import sys
@@ skipping 132 matching lines @@
   env.AddNodeToTestSuite(
       validator_py_test,
       ['small_tests', 'validator_tests'],
       'run_validator_py_test')
 
 # Source generation:
 #
 #   dfagen : Regenerate any autogenerated source files.
 
 ragel_targets = set([
-    'dfagen', 'dfacheckdecoder', 'dfacheckvalidator'])
+    'dfagen', 'dfacheckdecoder', 'dfacheckvalidator', 'dfafullcheckvalidator'])
 ragel_involved = ragel_targets.intersection(COMMAND_LINE_TARGETS)
 
 gas = env.MakeUntrustedNativeEnv()['AS']
 objdump = env.MakeUntrustedNativeEnv()['OBJDUMP']
 
 if ragel_involved:
   if not env.Bit('host_linux'):
     raise UserError('Right now DFA generation is only supported on Linux')
 
   # Source generation step 1: Build generator of ragel files.
@@ skipping 112 matching lines @@
     check_decoders.append(check_decoder)
 
   # Never run decoder tests in parallel because they can take all CPU.
   SideEffect('check_decoder', check_decoders)
 
   env.AlwaysBuild(env.Alias('dfagen', automata))
   env.AlwaysBuild(env.Alias('dfacheckdecoder', check_decoders))
 
   if python_can_load_dll:
 
+    # Fullcheck includes both [relatively] slow "regular instructions test"
+    # and [relatively] fast "regressions test".  Check only includes
+    # [relatively] fast "regressions test".
+    dfafullcheckvalidator_tests = []
     dfacheckvalidator_tests = []
 
     for bitness, xml in [('32', validator32_xml), ('64', validator64_xml)]:
       superinstruction = env.AutoDepsCommand(
           'superinstructions_x86_%s.txt' % bitness,
           ['${PYTHON}',
            env.File('verify_validators_dfa.py'),
            xml,
            '-o', '${TARGET}'])
 
       superinstruction_verified = env.AutoDepsCommand(
         'superinstructions_verified_x86_%s.out' % bitness,
         ['${PYTHON}',
          env.File('verify_superinstructions.py'),
          '--bitness', bitness,
          '--gas', gas,
          '--objdump', objdump,
          '--validator_dll', validator_dll,
          superinstruction])
 
       env.AlwaysBuild(superinstruction_verified)
+      dfafullcheckvalidator_tests.append(superinstruction_verified)
       dfacheckvalidator_tests.append(superinstruction_verified)
 
+      # Compare list of allowed instructions to python model
       regular_instructions_test = env.AutoDepsCommand(
         'regular_instructions_test_x86_%s.out' % bitness,
         ['${PYTHON}',
          env.File('verify_regular_instructions.py'),
          xml,
          '--bitness', bitness,
          '--validator_dll', validator_dll,
          '--decoder_dll', decoder_dll])
 
       # Never run exhaustive tests in parallel because they can take all CPU.
       env.AlwaysBuild(regular_instructions_test)
-      SideEffect('check_validator', regular_instructions_test)
-      dfacheckvalidator_tests.append(regular_instructions_test)
+      SideEffect('check_validator_full', regular_instructions_test)
+      dfafullcheckvalidator_tests.append(regular_instructions_test)
+
+      # Compress list of instructions and compare it to golden file
+      compress_regular_instructions_test = env.CommandTest(
+        '%sbit_regular.out' % bitness,
+        ['${PYTHON}',
+         env.File('compress_regular_instructions.py'),
+         xml,
+         '--bitness', bitness,
+         '--validator_dll', validator_dll,
+         '--decoder_dll', decoder_dll],
+        size = 'huge', scale_timeout = 16, capture_stderr = False,
+        stdout_golden = env.File('testdata/%sbit_regular.golden' % bitness))
+      SideEffect('check_validator', compress_regular_instructions_test)
+      dfacheckvalidator_tests.append(compress_regular_instructions_test)
 
       env32 = env.Clone(BUILD_TARGET_NAME='x86-32')
       env64 = env.Clone(BUILD_TARGET_NAME='x86-64')
       old_ncval32 = env32.File('$STAGING_DIR/ncval$PROGSUFFIX')
       old_ncval64 = env64.File('$STAGING_DIR/ncval$PROGSUFFIX')
 
       regular_instructions_old_test = env.AutoDepsCommand(
         'regular_instructions_old_test_x86_%s.out' % bitness,
         ['${PYTHON}',
          env.File('verify_regular_instructions_old.py'),
          xml,
          '--bitness', bitness,
          '--gas', gas,
          '--objdump', objdump,
          '--validator_dll', validator_dll,
          '--ncval32', old_ncval32,
          '--ncval64', old_ncval64,
          '--errors', '${TARGET}'])
 
       # Never run exhaustive tests in parallel because they can take all CPU.
       env.AlwaysBuild(regular_instructions_old_test)
-      SideEffect('check_validator', regular_instructions_old_test)
-      dfacheckvalidator_tests.append(regular_instructions_old_test)
+      SideEffect('check_validator_full', regular_instructions_old_test)
+      dfafullcheckvalidator_tests.append(regular_instructions_old_test)
 
     # There are three categories of protected files: validator files, generated
     # files (those of validator files that lie withing 'gen' directory) and
     # generating files (programs and input data used to produce generated
     # files).
     #
     # When validator files are changed, exhaustive validator tests have to be
     # rerun.  When generating files are changed, dfagen must be run to ensure
     # that generated files are up to date. Presubmit script uses
     # protected_files.json to perform these checks.
@@ skipping 41 matching lines @@
         canonical_filename = CanonicalizeFilename(filename)
         protected_files['generating'].append(canonical_filename)
       with open(target_filename, 'w') as target_file:
         json.dump(protected_files, target_file, sort_keys=True, indent=2)
 
     calculate_hash_sums = env.Command(
         target='%s/protected_files.json' % gen_dir,
         source=protected_files,
         action=CalculateHashSums)
     env.Depends(calculate_hash_sums, dfacheckvalidator_tests)
+    dfafullcheckvalidator_tests.append(calculate_hash_sums)
+    dfacheckvalidator_tests.append(calculate_hash_sums)
 
-    env.Alias('dfacheckvalidator', calculate_hash_sums)
+    env.Alias('dfafullcheckvalidator', dfafullcheckvalidator_tests)
+
+    env.Alias('dfacheckvalidator', dfacheckvalidator_tests)
 
 # Targeted tests: RDFA validator test, dis section checker and spec_val test.
 
 for bits in ['32', '64']:
   tests_mask = (
       '${MAIN_DIR}/src/trusted/validator_ragel/testdata/%s/*.test' % bits)
 
   if env.Bit('regenerate_golden'):
     update_option = ['--update']
   else:
@@ skipping 55 matching lines @@
 
   if env.Bit('regenerate_golden'):
     # Don't want these tests run in parallel because they write
     # to .test files.
     SideEffect(tests_mask, spec_test)
 
     # Spec test uses @dis section in test files, which in turn is updated
     # by dis_section_test.
     if env.Bit('target_x86'):
       env.Depends(spec_test, dis_section_test)