Fix FastAccessorAssembler inverted jump conditions

test/cctest/test-api-fast-accessor-builder.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 
 #include "include/v8.h"
 #include "include/v8-experimental.h"
 
 #include "src/api.h"
@@ skipping 171 matching lines @@
   // CheckNotZeroOrReturnNull:
   CompileRun(FN_WARMUP("nullcheck", "return obj.nullcheck"));
   obj->SetAlignedPointerInInternalField(0, /* anything != nullptr */ isolate);
   ExpectInt32("nullcheck()", 5);
   obj->SetAlignedPointerInInternalField(0, nullptr);
   ExpectNull("nullcheck()");
 
   // CheckFlagSetOrReturnNull:
   CompileRun(FN_WARMUP("maskcheck", "return obj.maskcheck"));
   obj->SetAlignedPointerInInternalField(1, reinterpret_cast<void*>(0xf0));
+  ExpectNull("maskcheck()");
+  obj->SetAlignedPointerInInternalField(1, reinterpret_cast<void*>(0xfe));
   ExpectInt32("maskcheck()", 42);
-  obj->SetAlignedPointerInInternalField(1, reinterpret_cast<void*>(0xfe));
-  ExpectNull("maskcheck()");
 }
 
 
 // "Fast" accessor with simple control flow via explicit labels.
 TEST(FastAccessorControlFlowWithLabels) {
   // Crankshaft support for fast accessors is not implemented; crankshafted
   // code uses the slow accessor which breaks this test's expectations.
   v8::internal::FLAG_always_opt = false;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
   foo->SetInternalFieldCount(1);
   {
     // accessor isnull: 0 for nullptr, else 1.
     auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
     auto label = builder->MakeLabel();
     auto val = builder->LoadInternalField(builder->GetReceiver(), 0);
     builder->CheckNotZeroOrJump(val, label);
+    builder->ReturnValue(builder->IntegerConstant(1));
+    builder->SetLabel(label);
     builder->ReturnValue(builder->IntegerConstant(0));
-    builder->SetLabel(label);
-    builder->ReturnValue(builder->IntegerConstant(1));
     foo->SetAccessorProperty(v8_str("isnull"),
                              v8::FunctionTemplate::NewWithFastHandler(
                                  isolate, NativePropertyAccessor, builder));
   }
 
   // Create an instance.
   v8::Local<v8::Object> obj = foo->NewInstance(env.local()).ToLocalChecked();
   CHECK(env->Global()->Set(env.local(), v8_str("obj"), obj).FromJust());
 
   // CheckNotZeroOrReturnNull:
@@ skipping 27 matching lines @@
   {
     // accessor intisnonzero
     int intval_offset =
         static_cast<int>(reinterpret_cast<intptr_t>(&val.intval) -
                          reinterpret_cast<intptr_t>(&val));
     auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
     auto label = builder->MakeLabel();
     auto val = builder->LoadValue(
         builder->LoadInternalField(builder->GetReceiver(), 0), intval_offset);
     builder->CheckNotZeroOrJump(val, label);
+    builder->ReturnValue(builder->IntegerConstant(1));
+    builder->SetLabel(label);
     builder->ReturnValue(builder->IntegerConstant(0));
-    builder->SetLabel(label);
-    builder->ReturnValue(builder->IntegerConstant(1));
     foo->SetAccessorProperty(v8_str("nonzero"),
                              v8::FunctionTemplate::NewWithFastHandler(
                                  isolate, NativePropertyAccessor, builder));
   }
   {
     // accessor loadval
     int v8val_offset = static_cast<int>(reinterpret_cast<intptr_t>(&val.v8val) -
                                         reinterpret_cast<intptr_t>(&val));
     auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
     builder->ReturnValue(builder->LoadObject(
@@ skipping 77 matching lines @@
   // Callbacks:
   CompileRun(FN_WARMUP("callbackint", "return obj.int"));
   ExpectInt32("callbackint()", 12345);
 
   CompileRun(FN_WARMUP("callbackstr", "return obj.str"));
   ExpectString("callbackstr()", kApiCallbackStringValue);
 
   CompileRun(FN_WARMUP("callbackparam", "return obj.param"));
   ExpectInt32("callbackparam()", 1000);
 }