Eliminate bundle_size parameter from validator interface.

src/trusted/validator_x86/ncval.c

 /*
  * 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.
  */
 
 /*
  * ncval.c - command line validator for NaCl.
  * Mostly for testing.
  */
@@ skipping 73 matching lines @@
  * Note: Values, other than 1, is only used for profiling.
  */
 static int NACL_FLAGS_validate_attempts = 1;
 
 /* Define the set of CPU features to use while validating. */
 static NaClCPUFeaturesX86 ncval_cpu_features;
 
 /* Define whether timing should be applied when running the validator. */
 static Bool NACL_FLAGS_print_timing = FALSE;
 
-/* Define the block alignment size to use. */
-static int NACL_FLAGS_block_alignment = 32;
-
 /* Define what level of errors will be printed.
  * Note: If multiple flags are true, the one with
  * the highest severity will be selected.
  */
 static Bool NACL_FLAGS_warnings = FALSE;
 static Bool NACL_FLAGS_errors = FALSE;
 static Bool NACL_FLAGS_fatal = FALSE;
 
 /* Define if special stubout tests should be run. Such
  * tests apply stubout, and then print out the modified
@@ skipping 222 matching lines @@
     NCValidateSegment(ncf->data + (phdr[ii].p_vaddr - ncf->vbase),
                       phdr[ii].p_vaddr, phdr[ii].p_memsz, vstate);
   }
   return -badsections;
 }
 
 /* Initialize segment validator, using detailed (summary) error
  * messages if selected.
  */
 struct NCValidatorState* NCValInit(const NaClPcAddress vbase,
-                                   const NaClMemorySize codesize,
-                                   const uint8_t alignment) {
+                                   const NaClMemorySize codesize) {
   return NACL_FLAGS_detailed_errors
-      ? NCValidateInitDetailed(vbase, codesize, alignment, &ncval_cpu_features)
-      : NCValidateInit(vbase, codesize, alignment, FALSE, &ncval_cpu_features);
+      ? NCValidateInitDetailed(vbase, codesize, &ncval_cpu_features)
+      : NCValidateInit(vbase, codesize, FALSE, &ncval_cpu_features);
 }
 
 
 static Bool AnalyzeSegmentCodeSegments(ncfile *ncf, const char *fname) {
   NaClPcAddress vbase, vlimit;
   struct NCValidatorState *vstate;
   Bool result;
 
   GetVBaseAndLimit(ncf, &vbase, &vlimit);
-  vstate = NCValInit(vbase, vlimit - vbase, ncf->ncalign);
+  vstate = NCValInit(vbase, vlimit - vbase);
   if (vstate == NULL) return FALSE;
   NCValidateSetErrorReporter(vstate, &kNCVerboseErrorReporter);
   if (AnalyzeSegmentSections(ncf, vstate) < 0) {
     NaClLog(LOG_INFO, "%s: text validate failed\n", fname);
   }
   result = (0 == NCValidateFinish(vstate)) ? TRUE : FALSE;
   NaClReportSafety(result, fname);
   if (NACL_FLAGS_stats_print) NCStatsPrint(vstate);
   NCValidateFreeState(&vstate);
   NaClLog(LOG_INFO, "Validated %s\n", fname);
@@ skipping 11 matching lines @@
  */
 static NaClOpKind nacl_base_register =
     (64 == NACL_TARGET_SUBARCH ? RegR15 : RegUnknown);
 
 /* Create validator state using detailed (summary) error messages
  * if selected.
  */
 struct NaClValidatorState* NaClValStateCreate(
     const NaClPcAddress vbase,
     const NaClMemorySize sz,
-    const uint8_t alignment,
     const NaClOpKind base_register) {
   return
       NACL_FLAGS_detailed_errors
-      ? NaClValidatorStateCreateDetailed(vbase, sz, alignment, base_register,
+      ? NaClValidatorStateCreateDetailed(vbase, sz, base_register,
                                          &ncval_cpu_features)
-      : NaClValidatorStateCreate(vbase, sz, alignment, base_register,
+      : NaClValidatorStateCreate(vbase, sz, base_register,
                                  FALSE, &ncval_cpu_features);
 }
 
 /* Returns the decoder tables to use. */
 static const NaClDecodeTables* NaClGetDecoderTables() {
   return NACL_FLAGS_validator_decoder
       ? kNaClValDecoderTables
       : kNaClDecoderTables;
 }
 
@@ skipping 54 matching lines @@
 /* Analyze each code segment in the given elf file, stored in the
  * file with the given path fname.
  */
 static Bool AnalyzeSfiCodeSegments(ncfile *ncf, const char *fname) {
   /* TODO(karl) convert these to be PcAddress and MemorySize */
   NaClPcAddress vbase, vlimit;
   NaClValidatorState *vstate;
   Bool return_value = TRUE;
 
   GetVBaseAndLimit(ncf, &vbase, &vlimit);
-  vstate = NaClValStateCreate(vbase, vlimit - vbase,
-                              ncf->ncalign, nacl_base_register);
+  vstate = NaClValStateCreate(vbase, vlimit - vbase, nacl_base_register);
   if (vstate == NULL) {
     NaClValidatorMessage(LOG_ERROR, vstate, "Unable to create validator state");
     return FALSE;
   }
   NaClValidatorStateSetErrorReporter(vstate, &kNaClVerboseErrorReporter);
   if (NACL_FLAGS_analyze_segments) {
     AnalyzeSfiSegments(ncf, vstate);
   } else {
     AnalyzeSfiSections(ncf, vstate);
   }
@@ skipping 41 matching lines @@
   NaClPcAddress base;
 } NaClValidateBytes;
 
 /* Apply the validator to the sequence of bytes in the given data. */
 static Bool NaClValidateAnalyzeBytes(NaClValidateBytes* data) {
   Bool return_value = FALSE;
 #if NACL_TARGET_SUBARCH == 64
   NaClValidatorState* state;
   state = NaClValStateCreate(data->base,
                              data->num_bytes,
-                             (uint8_t) NACL_FLAGS_block_alignment,
                              nacl_base_register);
   if (NULL == state) {
     NaClValidatorMessage(LOG_ERROR, NULL, "Unable to create validator state");
     return FALSE;
   }
   if (NACL_FLAGS_stubout_memory) {
     NaClValidatorStateSetDoStubOut(state, TRUE);
   }
   NaClValidatorStateSetErrorReporter(state, &kNaClVerboseErrorReporter);
   NaClValidateSegmentUsingTables(data->bytes, data->base, data->num_bytes,
                                  state, NaClGetDecoderTables());
   return_value = NaClValidatesOk(state);
   if (state->did_stub_out) {
     /* Used for golden file testing. */
     printf("Some instructions were replaced with HLTs.\n");
   }
   NaClValidatorStateDestroy(state);
   NaClReportSafety(return_value, "");
 #else
   struct NCValidatorState *vstate;
-  vstate = NCValInit(data->base, data->num_bytes,
-                     (uint8_t) NACL_FLAGS_block_alignment);
+  vstate = NCValInit(data->base, data->num_bytes);
   if (vstate == NULL) {
     printf("Unable to create validator state, quitting!\n");
   } else {
     if (NACL_FLAGS_stubout_memory) {
       NCValidateSetStubOutMode(vstate, 1);
     }
     NCValidateSetErrorReporter(vstate, &kNCVerboseErrorReporter);
     NCValidateSegment(&data->bytes[0], data->base, data->num_bytes, vstate);
     return_value = (0 == NCValidateFinish(vstate)) ? TRUE : FALSE;
     if (vstate->stats.didstubout) {
@@ skipping 268 matching lines @@
 
 /* Checks if arg is one of the expected "int" flags, and if so, sets
  * the corresponding flag and returns true.
  */
 static Bool GrokAnIntFlag(const char *arg) {
   /* A set of boolean flags to be checked */
   static struct {
     const char *flag_name;
     int *flag_ptr;
   } flags[] = {
-    { "--alignment" , &NACL_FLAGS_block_alignment },
     { "--max_errors", &NACL_FLAGS_max_reported_errors},
     { "--attempts"  , &NACL_FLAGS_validate_attempts },
   };
   int i;
   for (i = 0; i < NACL_ARRAY_SIZE(flags); ++i) {
     if (GrokIntFlag(flags[i].flag_name, arg, flags[i].flag_ptr)) {
       return TRUE;
     }
   }
   return FALSE;
@@ skipping 114 matching lines @@
         data.num_bytes, data.base);
     NaClMaybeDecodeDataSegment(&data.bytes[0], data.base, data.num_bytes);
     /* always succeed, so that the testing framework works. */
     result = 0;
   }
 
   NaClLogModuleFini();
   GioFileDtor(gout);
   return result;
 }