Merge 7712 - Ensure super instructions are marked during dynamic code modification.

src/trusted/validator/x86/ncval_seg_sfi/ncdecode.c

 /*
  * Copyright (c) 2011 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.
  */
 
 /*
  * ncdecode.c - table driven decoder for Native Client
  *
  * Most x86 decoders I've looked at are big case statements. While
@@ skipping 457 matching lines @@
  */
 static void NCDecoderStateInitFields(NCDecoderState* this) {
   size_t dbindex;
   this->error_reporter = &kNCNullErrorReporter;
   NCRemainingMemoryInit(this->mbase, this->size, &this->memory);
   this->memory.error_fn = NCRemainingMemoryInternalError;
   this->memory.error_fn_state = (void*) this;
   for (dbindex = 0; dbindex < this->inst_buffer_size; ++dbindex) {
     this->inst_buffer[dbindex].dstate       = this;
     this->inst_buffer[dbindex].inst_index   = dbindex;
-    this->inst_buffer[dbindex].inst_count   = 0;
+    this->inst_buffer[dbindex].inst_count   = 1;
     this->inst_buffer[dbindex].vpc          = 0;
+    this->inst_buffer[dbindex].unchanged    = FALSE;
     NCInstBytesInitMemory(&this->inst_buffer[dbindex].inst.bytes,
                           &this->memory);
     NCInstBytesPtrInit((NCInstBytesPtr*) &this->inst_buffer[dbindex].inst_bytes,
                        &this->inst_buffer[dbindex].inst.bytes);
   }
   this->cur_inst_index = 0;
   this->inst_buffer[0].vpc = this->vbase;
 }
 
 void NCDecoderStateConstruct(NCDecoderState* this,
@@ skipping 26 matching lines @@
  * in the ring buffer.  Reset the state of that next instruction.
  */
 static NCDecoderInst* IncrementInst(NCDecoderInst* inst) {
   /* giving PreviousInst a positive number will get NextInst
    * better to keep the buffer switching logic in one place
    */
   NCDecoderInst* next_inst = NCGetInstDiff(inst, 1);
   next_inst->vpc = inst->vpc + inst->inst.bytes.length;
   next_inst->dstate->cur_inst_index = next_inst->inst_index;
   next_inst->inst_count = inst->inst_count + 1;
+  next_inst->unchanged = FALSE;
   return next_inst;
 }
 
 /* Get the i-th byte of the current instruction being parsed. */
 static uint8_t GetInstByte(NCDecoderInst* dinst, ssize_t i) {
   if (i < dinst->inst.bytes.length) {
     return dinst->inst.bytes.byte[i];
   } else {
     return NCRemainingMemoryLookaheadInline(&dinst->dstate->memory,
                                             i - dinst->inst.bytes.length);
@@ skipping 94 matching lines @@
   (NaClPrintInst) NCNullErrorPrintInst,
 };
 
 Bool NCDecoderStateDecode(NCDecoderState* this) {
   NCDecoderInst* dinst = &this->inst_buffer[this->cur_inst_index];
   const NaClPcAddress vlimit = this->vbase + this->size;
   DEBUG( printf("DecodeSegment(%p[%"NACL_PRIxNaClPcAddress
                 "-%"NACL_PRIxNaClPcAddress"])\n",
                 (void*) this->memory.mpc, this->vbase, vlimit) );
   NCDecoderStateNewSegment(this);
-  dinst->inst_count = 1;
   while (dinst->vpc < vlimit) {
     ConsumeNextInstruction(dinst);
     if (this->memory.overflow_count) {
       NaClPcAddress newpc = dinst->vpc + dinst->inst.bytes.length;
       (*this->error_reporter->printf)(
           this->error_reporter,
           "%"NACL_PRIxNaClPcAddress" > %"NACL_PRIxNaClPcAddress
           " (read overflow of %d bytes)\n",
           newpc, vlimit, this->memory.overflow_count);
       ErrorSegmentation(dinst);
@@ skipping 98 matching lines @@
     if (! (tthis->action_fn)(tthis, old_dinst, new_dinst)) {
       return FALSE;
     }
 
     /* Move to next instruction. */
     old_dinst = IncrementInst(old_dinst);
     new_dinst = IncrementInst(new_dinst);
   }
   return TRUE;
 }