Ignore:
Timestamp:
Apr 17, 2017, 1:24:48 AM (8 years ago)
Author:
[email protected]
Message:

B3: don't allow unsigned offsets in Value
​https://bugs.webkit.org/show_bug.cgi?id=170692

Reviewed by Filip Pizlo.

Source/JavaScriptCore:

MemoryValue and similar B3 opcode classes always expects a signed
offset. Giving it an out-of-bounds unsigned offset causes
implementation-defined behavior, which can cause badness as I just
fixed in WebAssembly. This patch makes it impossible to create a
Value opcodes with an unsigned value, or with an overly-large
value.

  • b3/B3AtomicValue.cpp:

(JSC::B3::AtomicValue::AtomicValue):

  • b3/B3AtomicValue.h:
  • b3/B3Common.h:

(JSC::B3::isRepresentableAs):

  • b3/B3EliminateCommonSubexpressions.cpp:
  • b3/B3LowerToAir.cpp:

(JSC::B3::Air::LowerToAir::scaleForShl):
(JSC::B3::Air::LowerToAir::effectiveAddr):
(JSC::B3::Air::LowerToAir::addr):
(JSC::B3::Air::LowerToAir::tryAppendLea):

  • b3/B3MemoryValue.cpp:

(JSC::B3::MemoryValue::isLegalOffsetImpl):
(JSC::B3::MemoryValue::MemoryValue):

  • b3/B3MemoryValue.h:
  • b3/B3MemoryValueInlines.h:

(JSC::B3::MemoryValue::isLegalOffsetImpl):

  • b3/B3MoveConstants.cpp:
  • b3/B3ReduceStrength.cpp:
  • b3/B3StackmapSpecial.cpp:

(JSC::B3::StackmapSpecial::repForArg):

  • b3/B3Value.h:
  • b3/air/AirArg.cpp:

(JSC::B3::Air::Arg::stackAddrImpl):

  • b3/air/AirArg.h:

(JSC::B3::Air::Arg::addr):
(JSC::B3::Air::Arg::stack):
(JSC::B3::Air::Arg::callArg):
(JSC::B3::Air::Arg::stackAddr):
(JSC::B3::Air::Arg::index):
(JSC::B3::Air::Arg::offset):
(JSC::B3::Air::Arg::isValidAddrForm):
(JSC::B3::Air::Arg::isValidIndexForm):
(JSC::B3::Air::Arg::asTrustedImm32):
(JSC::B3::Air::Arg::asAddress):
(JSC::B3::Air::Arg::asBaseIndex):

  • b3/air/AirLowerStackArgs.cpp:

(JSC::B3::Air::lowerStackArgs):

  • b3/testb3.cpp:

(JSC::B3::testMulArgStore):
(JSC::B3::testStore32):
(JSC::B3::testStoreConstant):
(JSC::B3::testStoreConstantPtr):
(JSC::B3::testStoreAddLoad32):
(JSC::B3::testStoreAddLoadImm32):
(JSC::B3::testStoreAddLoad8):
(JSC::B3::testStoreAddLoadImm8):
(JSC::B3::testStoreAddLoad16):
(JSC::B3::testStoreAddLoadImm16):
(JSC::B3::testStoreAddLoad64):
(JSC::B3::testStoreAddLoadImm64):
(JSC::B3::testStoreAddLoad32Index):
(JSC::B3::testStoreAddLoadImm32Index):
(JSC::B3::testStoreAddLoad64Index):
(JSC::B3::testStoreAddLoadImm64Index):
(JSC::B3::testStoreSubLoad):
(JSC::B3::testStoreAddLoadInterference):
(JSC::B3::testStoreAddAndLoad):
(JSC::B3::testStoreNegLoad32):
(JSC::B3::testStoreNegLoadPtr):
(JSC::B3::testLoadOffset):
(JSC::B3::testLoadOffsetNotConstant):
(JSC::B3::testLoadOffsetUsingAdd):
(JSC::B3::testLoadOffsetUsingAddInterference):
(JSC::B3::testLoadOffsetUsingAddNotConstant):
(JSC::B3::testStoreLoadStackSlot):
(JSC::B3::testLoad):
(JSC::B3::testInterpreter):
(JSC::B3::testTrappingStore):
(JSC::B3::testTrappingLoadAddStore):
(JSC::B3::testWasmAddress):

  • wasm/WasmB3IRGenerator.cpp:

(JSC::Wasm::B3IRGenerator::fixupPointerPlusOffset):
(JSC::Wasm::B3IRGenerator::emitCheckAndPreparePointer):
(JSC::Wasm::B3IRGenerator::emitLoadOp):
(JSC::Wasm::B3IRGenerator::emitStoreOp):

Source/WTF:

Add C++17's std::conjunction type trait, except for Microsoft VS
2015 update 2 and later because it adds the logical operator type
traits, event when C++ is pre-2017:
​https://blogs.msdn.microsoft.com/vcblog/2016/01/22/vs-2015-update-2s-stl-is-c17-so-far-feature-complete/

  • wtf/StdLibExtras.h:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/b3/testb3.cpp

    r215340 r215407  
    880880    root->appendNew<MemoryValue>(
    881881        proc, Store, Origin(), value,
    882         root->appendNew<ConstPtrValue>(proc, Origin(), &valueSlot));
     882        root->appendNew<ConstPtrValue>(proc, Origin(), &valueSlot), 0);
    883883    root->appendNew<MemoryValue>(
    884884        proc, Store, Origin(), mul,
    885         root->appendNew<ConstPtrValue>(proc, Origin(), &mulSlot));
     885        root->appendNew<ConstPtrValue>(proc, Origin(), &mulSlot), 0);
    886886
    887887    root->appendNewControlValue(
    … …  
    54225422            proc, Trunc, Origin(),
    54235423            root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
    5424         root->appendNew<ConstPtrValue>(proc, Origin(), &slot));
     5424        root->appendNew<ConstPtrValue>(proc, Origin(), &slot), 0);
    54255425    root->appendNewControlValue(
    54265426        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    … …  
    54385438        proc, Store, Origin(),
    54395439        root->appendNew<Const32Value>(proc, Origin(), value),
    5440         root->appendNew<ConstPtrValue>(proc, Origin(), &slot));
     5440        root->appendNew<ConstPtrValue>(proc, Origin(), &slot), 0);
    54415441    root->appendNewControlValue(
    54425442        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    … …  
    54585458        proc, Store, Origin(),
    54595459        root->appendNew<ConstPtrValue>(proc, Origin(), value),
    5460         root->appendNew<ConstPtrValue>(proc, Origin(), &slot));
     5460        root->appendNew<ConstPtrValue>(proc, Origin(), &slot), 0);
    54615461    root->appendNewControlValue(
    54625462        proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
    … …  
    57605760                proc, Trunc, Origin(),
    57615761                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
    5762         slotPtr);
     5762        slotPtr, 0);
    57635763    root->appendNewControlValue(
    57645764        proc, Return, Origin(),
    … …  
    58105810            root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), slotPtr),
    58115811            root->appendNew<Const32Value>(proc, Origin(), amount)),
    5812         slotPtr);
     5812        slotPtr, 0);
    58135813    root->appendNewControlValue(
    58145814        proc, Return, Origin(),
    … …  
    58335833                proc, Trunc, Origin(),
    58345834                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
    5835         slotPtr);
     5835        slotPtr, 0);
    58365836    root->appendNewControlValue(
    58375837        proc, Return, Origin(),
    … …  
    59225922            root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),
    59235923            root->appendNew<Const32Value>(proc, Origin(), amount)),
    5924         slotPtr);
     5924        slotPtr, 0);
    59255925    root->appendNewControlValue(
    59265926        proc, Return, Origin(),
    … …  
    59455945                proc, Trunc, Origin(),
    59465946                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
    5947         slotPtr);
     5947        slotPtr, 0);
    59485948    root->appendNewControlValue(
    59495949        proc, Return, Origin(),
    … …  
    59955995            root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),
    59965996            root->appendNew<Const32Value>(proc, Origin(), amount)),
    5997         slotPtr);
     5997        slotPtr, 0);
    59985998    root->appendNewControlValue(
    59995999        proc, Return, Origin(),
    … …  
    60166016            root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),
    60176017            root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
    6018         slotPtr);
     6018        slotPtr, 0);
    60196019    root->appendNewControlValue(
    60206020        proc, Return, Origin(),
    … …  
    60646064            root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),
    60656065            root->appendNew<Const64Value>(proc, Origin(), amount)),
    6066         slotPtr);
     6066        slotPtr, 0);
    60676067    root->appendNewControlValue(
    60686068        proc, Return, Origin(),
    … …  
    60966096                proc, Trunc, Origin(),
    60976097                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
    6098         slotPtr);
     6098        slotPtr, 0);
    60996099    root->appendNewControlValue(
    61006100        proc, Return, Origin(),
    … …  
    61266126            root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), slotPtr),
    61276127            root->appendNew<Const32Value>(proc, Origin(), amount)),
    6128         slotPtr);
     6128        slotPtr, 0);
    61296129    root->appendNewControlValue(
    61306130        proc, Return, Origin(),
    … …  
    62806280            root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),
    62816281            root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
    6282         slotPtr);
     6282        slotPtr, 0);
    62836283    root->appendNewControlValue(
    62846284        proc, Return, Origin(),
    … …  
    63106310            root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),
    63116311            root->appendNew<Const64Value>(proc, Origin(), amount)),
    6312         slotPtr);
     6312        slotPtr, 0);
    63136313    root->appendNewControlValue(
    63146314        proc, Return, Origin(),
    … …  
    63346334                proc, Trunc, Origin(),
    63356335                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
    6336         slotPtr);
     6336        slotPtr, 0);
    63376337    root->appendNewControlValue(
    63386338        proc, Return, Origin(),
    … …  
    63556355        proc, Store, Origin(),
    63566356        root->appendNew<Const32Value>(proc, Origin(), 666),
    6357         otherSlotPtr);
     6357        otherSlotPtr, 0);
    63586358    root->appendNew<MemoryValue>(
    63596359        proc, Store, Origin(),
    … …  
    63616361            proc, Add, Origin(),
    63626362            load, root->appendNew<Const32Value>(proc, Origin(), amount)),
    6363         slotPtr);
     6363        slotPtr, 0);
    63646364    root->appendNewControlValue(
    63656365        proc, Return, Origin(),
    … …  
    63856385                root->appendNew<Const32Value>(proc, Origin(), amount)),
    63866386            root->appendNew<Const32Value>(proc, Origin(), mask)),
    6387         slotPtr);
     6387        slotPtr, 0);
    63886388    root->appendNewControlValue(
    63896389        proc, Return, Origin(),
    … …  
    64096409            root->appendNew<Const32Value>(proc, Origin(), 0),
    64106410            root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), slotPtr)),
    6411         slotPtr);
     6411        slotPtr, 0);
    64126412   
    64136413    root->appendNewControlValue(
    … …  
    64336433            root->appendNew<ConstPtrValue>(proc, Origin(), 0),
    64346434            root->appendNew<MemoryValue>(proc, Load, pointerType(), Origin(), slotPtr)),
    6435         slotPtr);
     6435        slotPtr, 0);
    64366436   
    64376437    root->appendNewControlValue(
    … …  
    64696469            proc, Add, Origin(),
    64706470            root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), arrayPtr, 0),
    6471             root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), arrayPtr, sizeof(int))));
     6471            root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), arrayPtr, static_cast<int32_t>(sizeof(int)))));
    64726472
    64736473    CHECK(compileAndRun<int>(proc) == array[0] + array[1]);
    … …  
    64856485            proc, Add, Origin(),
    64866486            root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), arrayPtr, 0),
    6487             root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), arrayPtr, sizeof(int))));
     6487            root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), arrayPtr, static_cast<int32_t>(sizeof(int)))));
    64886488
    64896489    CHECK(compileAndRun<int>(proc, &array[0]) == array[0] + array[1]);
    … …  
    65096509                root->appendNew<Value>(
    65106510                    proc, Add, Origin(), arrayPtr,
    6511                     root->appendNew<ConstPtrValue>(proc, Origin(), sizeof(int))))));
     6511                    root->appendNew<ConstPtrValue>(proc, Origin(), static_cast<int32_t>(sizeof(int)))))));
    65126512   
    65136513    CHECK(compileAndRun<int>(proc) == array[0] + array[1]);
    … …  
    65326532        root->appendNew<Value>(
    65336533            proc, Add, Origin(), arrayPtr,
    6534             root->appendNew<ConstPtrValue>(proc, Origin(), sizeof(int))));
     6534            root->appendNew<ConstPtrValue>(proc, Origin(), static_cast<int32_t>(sizeof(int)))));
    65356535    root->appendNew<MemoryValue>(
    65366536        proc, Store, Origin(), theNumberOfTheBeast, otherArrayPtr, 0);
    65376537    root->appendNew<MemoryValue>(
    6538         proc, Store, Origin(), theNumberOfTheBeast, otherArrayPtr, sizeof(int));
     6538        proc, Store, Origin(), theNumberOfTheBeast, otherArrayPtr, static_cast<int32_t>(sizeof(int)));
    65396539    root->appendNewControlValue(
    65406540        proc, Return, Origin(),
    … …  
    65666566                root->appendNew<Value>(
    65676567                    proc, Add, Origin(), arrayPtr,
    6568                     root->appendNew<ConstPtrValue>(proc, Origin(), sizeof(int))))));
     6568                    root->appendNew<ConstPtrValue>(proc, Origin(), static_cast<int32_t>(sizeof(int)))))));
    65696569   
    65706570    CHECK(compileAndRun<int>(proc, &array[0]) == array[0] + array[1]);
    … …  
    66916691            proc, Trunc, Origin(),
    66926692            root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
    6693         stack);
     6693        stack, 0);
    66946694   
    66956695    root->appendNewControlValue(
    … …  
    67616761                proc, opcode, type, Origin(),
    67626762                root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
    6763                 sizeof(InputType)));
     6763                static_cast<int32_t>(sizeof(InputType))));
    67646764
    67656765        CHECK(isIdentical(compileAndRun<CType>(proc, &value - 1), modelLoad<CType>(value)));
    … …  
    1290312903                proc, Mul, Origin(),
    1290412904                addToDataPointer->appendNew<MemoryValue>(
    12905                     proc, Load, pointerType(), Origin(), codePointerValue, sizeof(intptr_t)),
     12905                    proc, Load, pointerType(), Origin(), codePointerValue, static_cast<int32_t>(sizeof(intptr_t))),
    1290612906                addToDataPointer->appendIntConstant(
    1290712907                    proc, Origin(), pointerType(), sizeof(intptr_t)))));
    … …  
    1293212932                proc, Mul, Origin(),
    1293312933                addToCodePointerTaken->appendNew<MemoryValue>(
    12934                     proc, Load, pointerType(), Origin(), codePointerValue, sizeof(intptr_t)),
     12934                    proc, Load, pointerType(), Origin(), codePointerValue, static_cast<int32_t>(sizeof(intptr_t))),
    1293512935                addToCodePointerTaken->appendIntConstant(
    1293612936                    proc, Origin(), pointerType(), sizeof(intptr_t)))));
    … …  
    1295512955                proc, Load, pointerType(), Origin(), dataPointerValue),
    1295612956            addToData->appendNew<MemoryValue>(
    12957                 proc, Load, pointerType(), Origin(), codePointerValue, sizeof(intptr_t))),
     12957                proc, Load, pointerType(), Origin(), codePointerValue, static_cast<int32_t>(sizeof(intptr_t)))),
    1295812958        dataPointerValue);
    1295912959    addToData->appendNew<VariableValue>(
    … …  
    1387613876        proc, trapping(Store), Origin(),
    1387713877        root->appendNew<Const32Value>(proc, Origin(), 111),
    13878         root->appendNew<ConstPtrValue>(proc, Origin(), &x));
     13878        root->appendNew<ConstPtrValue>(proc, Origin(), &x), 0);
    1387913879    Effects expectedEffects;
    1388013880    expectedEffects.exitsSideways = true;
    … …  
    1391313913            root->appendNew<MemoryValue>(proc, trapping(Load), Int32, Origin(), ptr),
    1391413914            root->appendNew<Const32Value>(proc, Origin(), 3)),
    13915         ptr);
     13915        ptr, 0);
    1391613916    root->appendNew<Value>(proc, Return, Origin());
    1391713917    compileAndRun<int>(proc);
    … …  
    1522915229    pointer = body->appendNew<Value>(proc, ZExt32, Origin(), pointer);
    1523015230    body->appendNew<MemoryValue>(proc, Store, Origin(), valueToStore,
    15231         body->appendNew<WasmAddressValue>(proc, Origin(), pointer, pinnedGPR));
     15231        body->appendNew<WasmAddressValue>(proc, Origin(), pointer, pinnedGPR), 0);
    1523215232    UpsilonValue* incUpsilon = body->appendNew<UpsilonValue>(proc, Origin(),
    1523315233        body->appendNew<Value>(proc, Add, Origin(), indexPhi,
Note: See TracChangeset for help on using the changeset viewer.