A mechanism to identify/forbid/"rewrite" non-temporal instructions (and other)

src/trusted/validator_ragel/dfa_validate_64.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.
  */
 
 /* Implement the Validator API for the x86-64 architecture. */
 #include <errno.h>
 #include <string.h>
 
@@ skipping 12 matching lines @@
 #if NACL_ARCH(NACL_BUILD_ARCH) != NACL_x86 || NACL_BUILD_SUBARCH != 64
 # error "Can't compile, target is for x86-64"
 #endif
 
 
 static NaClValidationStatus ApplyDfaValidator_x86_64(
     uintptr_t guest_addr,
     uint8_t *data,
     size_t size,
     int stubout_mode,
+    int pnacl_mode,
     int readonly_text,
     const NaClCPUFeatures *f,
     const struct NaClValidationMetadata *metadata,
     struct NaClValidationCache *cache) {
   /* TODO(jfb) Use a safe cast here. */
   NaClCPUFeaturesX86 *cpu_features = (NaClCPUFeaturesX86 *) f;
   enum NaClValidationStatus status = NaClValidationFailed;
-  int did_stubout = 0;
   void *query = NULL;
+  struct ForbidRewriteCallbackData callback_data;
+  callback_data.pnacl_mode = pnacl_mode;
   UNREFERENCED_PARAMETER(guest_addr);
 
   if (stubout_mode)
     return NaClValidationFailedNotImplemented;
   if (!NaClArchSupportedX86(cpu_features))
     return NaClValidationFailedCpuNotSupported;
   if (size & kBundleMask)
     return NaClValidationFailed;
 
   /*
    * If the validation caching interface is available and it would be
    * inexpensive to do so, perform a query.
    */
   if (cache != NULL && NaClCachingIsInexpensive(cache, metadata))
     query = cache->CreateQuery(cache->handle);
   if (query != NULL) {
     const char validator_id[] = "x86-64 dfa";
     cache->AddData(query, (uint8_t *) validator_id, sizeof(validator_id));
     cache->AddData(query, (uint8_t *) cpu_features, sizeof(*cpu_features));
     NaClAddCodeIdentity(data, size, metadata, cache, query);
     if (cache->QueryKnownToValidate(query)) {
       cache->DestroyQuery(query);
       return NaClValidationSucceeded;
     }
   }
 
   if (readonly_text) {
     if (ValidateChunkAMD64(data, size, 0 /*options*/, cpu_features,
-                           NaClDfaProcessValidationError,
-                           NULL))
+          NaClDfaProcessValidationError,
+          NULL))
       status = NaClValidationSucceeded;
   } else {
     if (ValidateChunkAMD64(data, size, 0 /*options*/, cpu_features,
-                           NaClDfaStubOutCPUUnsupportedInstruction,
-                           &did_stubout))
+          NaClDfaForbidOrRewriteInstruction,
+          &callback_data))
       status = NaClValidationSucceeded;
   }
 
   if (status != NaClValidationSucceeded && errno == ENOMEM)
     status = NaClValidationFailedOutOfMemory;
 
   /* Cache the result if validation succeeded and the code was not modified. */
   if (query != NULL) {
-    if (status == NaClValidationSucceeded && did_stubout == 0)
+    if (status == NaClValidationSucceeded && callback_data.did_rewrite == 0)
       cache->SetKnownToValidate(query);
     cache->DestroyQuery(query);
   }
 
   return status;
 }
 
 
 static NaClValidationStatus ValidatorCodeCopy_x86_64(
     uintptr_t guest_addr,
@@ skipping 204 matching lines @@
   sizeof(NaClCPUFeaturesX86),
   NaClSetAllCPUFeaturesX86,
   NaClGetCurrentCPUFeaturesX86,
   NaClFixCPUFeaturesX86,
   IsOnInstBoundary_x86_64,
 };
 
 const struct NaClValidatorInterface *NaClDfaValidatorCreate_x86_64(void) {
   return &validator;
 }