Changeset 205330 in webkit


Ignore:
Timestamp:
Sep 1, 2016 6:19:42 PM (8 years ago)
Author:
keith_miller@apple.com
Message:

jsc: provide printErr()
​https://bugs.webkit.org/show_bug.cgi?id=161513

Patch by JF Bastien <​jfbastien@apple.com> on 2016-09-01
Reviewed by Mark Lam.

  • jsc.cpp:

(GlobalObject::finishCreation):
(printInternal): renamed from functionPrint, add error checking
(functionPrintStdOut): punt to printInternal
(functionPrintStdErr): punt to printInternal
(functionPrint): Deleted.

Location:
trunk/Source/JavaScriptCore
Files:
1 added
12 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/B3CallingConventions.cpp

    r205329 r205330  
    11/*
    2  * Copyright (C) 2012, 2013 Apple Inc. All rights reserved.
     2 * Copyright (C) 2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2121 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    2222 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2424 */
    2525
    26 #ifndef LLIntThunks_h
    27 #define LLIntThunks_h
     26#include "config.h"
     27#include "B3CallingConventions.h"
    2828
    29 #include "MacroAssemblerCodeRef.h"
     29#include <wtf/NeverDestroyed.h>
     30
     31#if ENABLE(B3_JIT)
    3032
    3133namespace JSC {
    3234
    33 class VM;
    34 struct ProtoCallFrame;
     35namespace B3 {
    3536
    36 extern "C" {
    37     EncodedJSValue vmEntryToJavaScript(void*, VM*, ProtoCallFrame*);
    38     EncodedJSValue vmEntryToNative(void*, VM*, ProtoCallFrame*);
     37JSCCallingConvention& jscCallingConvention()
     38{
     39    static LazyNeverDestroyed<JSCCallingConvention> staticJSCCallingConvention;
     40    static std::once_flag staticJSCCallingConventionFlag;
     41    std::call_once(staticJSCCallingConventionFlag, [] () {
     42        staticJSCCallingConvention.construct(Vector<GPRReg>(), RegisterSet::calleeSaveRegisters());
     43    });
     44
     45    return staticJSCCallingConvention;
    3946}
    4047
    41 namespace LLInt {
     48} // namespace B3
    4249
    43 MacroAssemblerCodeRef functionForCallEntryThunkGenerator(VM*);
    44 MacroAssemblerCodeRef functionForConstructEntryThunkGenerator(VM*);
    45 MacroAssemblerCodeRef functionForCallArityCheckThunkGenerator(VM*);
    46 MacroAssemblerCodeRef functionForConstructArityCheckThunkGenerator(VM*);
    47 MacroAssemblerCodeRef evalEntryThunkGenerator(VM*);
    48 MacroAssemblerCodeRef programEntryThunkGenerator(VM*);
    49 MacroAssemblerCodeRef moduleProgramEntryThunkGenerator(VM*);
     50} // namespace JSC
    5051
    51 } } // namespace JSC::LLInt
    52 
    53 #endif // LLIntThunks_h
     52#endif // ENABLE(B3_JIT)

  • trunk/Source/JavaScriptCore/ChangeLog

    r205328 r205330  
    7979        * runtime/CommonSlowPaths.cpp:
    8080        (JSC::SLOW_PATH_DECL):
     81
     822016-09-01  Keith Miller  <keith_miller@apple.com>
     83
     84        WASM functions should be able to use arguments
     85        https://bugs.webkit.org/show_bug.cgi?id=161471
     86
     87        Reviewed by Benjamin Poulain.
     88
     89        This patch does a couple of changes:
     90
     91        1) Adds a new Calling Convention class for B3. This class is used to make it easy to specify the calling convention of a function. In particular it knows which arguments are in registers and which ones should be on the stack. For now, nothing uses the argument registers, in the future we will use these for WASM and/or JS. Additonally, it knows the callee save registers for any given function. The main advantage of this class is that it makes it easy to iterate over the arguments of your function without having to worry about the details of the calling convention you are using.
     92
     93        2) Makes the WASM calling convention the same as the JS one. Currently, the CodeBlock, CodeOrigin, and Callee are all 0. Since they have no value. Additionally, since we call into WASM from C++ through vmEntryToJavaScript, if there are no arguments to the callee we insert a null pointer as the first argument.
     94
     95        3) Since WASM expects the arguments to be mapped to function locals we map the argument stack slots to variables immediately after the function prologue.
     96
     97        * B3CallingConventions.cpp: Copied from Source/JavaScriptCore/llint/LLIntThunks.h.
     98        (JSC::B3::jscCallingConvention):
     99        * B3CallingConventions.h: Added.
     100        (JSC::B3::CallingConvention::CallingConvention):
     101        (JSC::B3::CallingConvention::iterate):
     102        (JSC::B3::nextJSCOffset):
     103        * JavaScriptCore.xcodeproj/project.pbxproj:
     104        * interpreter/ProtoCallFrame.h:
     105        * llint/LLIntThunks.cpp:
     106        (JSC::vmEntryToWASM):
     107        * llint/LLIntThunks.h:
     108        * testWASM.cpp:
     109        (invoke):
     110        (box):
     111        (runWASMTests):
     112        * wasm/WASMB3IRGenerator.cpp:
     113        (JSC::WASM::B3IRGenerator::addLocal):
     114        (JSC::WASM::B3IRGenerator::addArguments):
     115        (JSC::WASM::B3IRGenerator::getLocal):
     116        * wasm/WASMFormat.h:
     117        * wasm/WASMFunctionParser.h:
     118        (JSC::WASM::FunctionParser<Context>::FunctionParser):
     119        (JSC::WASM::FunctionParser<Context>::parseExpression):
     120        * wasm/WASMModuleParser.cpp:
     121        (JSC::WASM::ModuleParser::parseFunctionTypes):
     122        (JSC::WASM::ModuleParser::parseFunctionSignatures):
     123        * wasm/WASMModuleParser.h:
     124        * wasm/WASMOps.h:
    81125
    821262016-09-01  Keith Miller  <keith_miller@apple.com>

  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r205198 r205330  
    11801180                531374BD1D5CE67600AF7A0B /* WASMPlan.h in Headers */ = {isa = PBXBuildFile; fileRef = 531374BC1D5CE67600AF7A0B /* WASMPlan.h */; };
    11811181                531374BF1D5CE95000AF7A0B /* WASMPlan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 531374BE1D5CE95000AF7A0B /* WASMPlan.cpp */; };
     1182                531B3C871D74C603005B3236 /* B3CallingConventions.h in Headers */ = {isa = PBXBuildFile; fileRef = 531B3C861D74C603005B3236 /* B3CallingConventions.h */; };
    11821183                53486BB71C1795C300F6F3AF /* JSTypedArray.h in Headers */ = {isa = PBXBuildFile; fileRef = 53486BB61C1795C300F6F3AF /* JSTypedArray.h */; settings = {ATTRIBUTES = (Public, ); }; };
    11831184                53486BBB1C18E84500F6F3AF /* JSTypedArray.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 53486BBA1C18E84500F6F3AF /* JSTypedArray.cpp */; };
    … …  
    11881189                5370B4F51BF26202005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5370B4F31BF25EA2005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.cpp */; };
    11891190                5370B4F61BF26205005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 5370B4F41BF25EA2005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.h */; };
     1191                5388B4041D76640B00D3D852 /* B3CallingConventions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5388B4031D76640B00D3D852 /* B3CallingConventions.cpp */; };
    11901192                53917E7B1B7906FA000EBD33 /* JSGenericTypedArrayViewPrototypeFunctions.h in Headers */ = {isa = PBXBuildFile; fileRef = 53917E7A1B7906E4000EBD33 /* JSGenericTypedArrayViewPrototypeFunctions.h */; };
    11911193                539EB0791D55607000C82EF7 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 51F0EB6105C86C6B00E6DF1B /* Foundation.framework */; };
    … …  
    33723374                531374BC1D5CE67600AF7A0B /* WASMPlan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WASMPlan.h; sourceTree = "<group>"; };
    33733375                531374BE1D5CE95000AF7A0B /* WASMPlan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WASMPlan.cpp; sourceTree = "<group>"; };
     3376                531B3C861D74C603005B3236 /* B3CallingConventions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = B3CallingConventions.h; sourceTree = "<group>"; };
    33743377                53486BB61C1795C300F6F3AF /* JSTypedArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSTypedArray.h; sourceTree = "<group>"; };
    33753378                53486BBA1C18E84500F6F3AF /* JSTypedArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSTypedArray.cpp; sourceTree = "<group>"; };
    … …  
    33823385                5370B4F31BF25EA2005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AdaptiveInferredPropertyValueWatchpointBase.cpp; sourceTree = "<group>"; };
    33833386                5370B4F41BF25EA2005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AdaptiveInferredPropertyValueWatchpointBase.h; sourceTree = "<group>"; };
     3387                5388B4031D76640B00D3D852 /* B3CallingConventions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = B3CallingConventions.cpp; sourceTree = "<group>"; };
    33843388                53917E7A1B7906E4000EBD33 /* JSGenericTypedArrayViewPrototypeFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSGenericTypedArrayViewPrototypeFunctions.h; sourceTree = "<group>"; };
    33853389                53917E7C1B791106000EBD33 /* JSTypedArrayViewPrototype.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSTypedArrayViewPrototype.h; sourceTree = "<group>"; };
    … …  
    47764780                                0F6B8ADE1C4EFE1700969052 /* B3BreakCriticalEdges.cpp */,
    47774781                                0F6B8ADF1C4EFE1700969052 /* B3BreakCriticalEdges.h */,
     4782                                5388B4031D76640B00D3D852 /* B3CallingConventions.cpp */,
     4783                                531B3C861D74C603005B3236 /* B3CallingConventions.h */,
    47784784                                DC9A0C1C1D2D94EF0085124E /* B3CaseCollection.cpp */,
    47794785                                DC9A0C1D1D2D94EF0085124E /* B3CaseCollection.h */,
    … …  
    48904896                                0FEC84F01BDACDAC0080FF74 /* B3SwitchValue.h */,
    48914897                                0F45703E1BE584CA0062A629 /* B3TimingScope.cpp */,
     4898                                0FEC84F21BDACDAC0080FF74 /* B3Type.h */,
    48924899                                0F45703F1BE584CA0062A629 /* B3TimingScope.h */,
    48934900                                0FEC84F11BDACDAC0080FF74 /* B3Type.cpp */,
    4894                                 0FEC84F21BDACDAC0080FF74 /* B3Type.h */,
    48954901                                DCFDFBD81D1F5D9800FE3D72 /* B3TypeMap.h */,
    48964902                                0FEC84F31BDACDAC0080FF74 /* B3UpsilonValue.cpp */,
    … …  
    82668272                                0F963B3813FC6FE90002D9B2 /* ValueProfile.h in Headers */,
    82678273                                0F426A481460CBB300131F8F /* ValueRecovery.h in Headers */,
     8274                                531B3C871D74C603005B3236 /* B3CallingConventions.h in Headers */,
    82688275                                79EE0C001B4AFB85000385C9 /* VariableEnvironment.h in Headers */,
    82698276                                0F6C73511AC9F99F00BE1682 /* VariableWriteFireDetail.h in Headers */,
    … …  
    89178924                                C2FCAE1217A9C24E0034C735 /* BytecodeLivenessAnalysis.cpp in Sources */,
    89188925                                0F338E0D1BF0276C0013C88F /* B3DataSection.cpp in Sources */,
     8926                                5388B4041D76640B00D3D852 /* B3CallingConventions.cpp in Sources */,
    89198927                                65B8392F1BACAD6A0044E824 /* CachedRecovery.cpp in Sources */,
    89208928                                1428082D107EC0570013E7B2 /* CallData.cpp in Sources */,

  • trunk/Source/JavaScriptCore/interpreter/ProtoCallFrame.h

    r183935 r205330  
    3131namespace JSC {
    3232
    33 struct ProtoCallFrame {
     33struct JS_EXPORT_PRIVATE ProtoCallFrame {
    3434    Register codeBlockValue;
    3535    Register calleeValue;

  • trunk/Source/JavaScriptCore/llint/LLIntThunks.cpp

    r204912 r205330  
    4242namespace JSC {
    4343
     44EncodedJSValue JS_EXPORT_PRIVATE vmEntryToWASM(void* code, VM* vm, ProtoCallFrame* frame)
     45{
     46    return vmEntryToJavaScript(code, vm, frame);
     47}
     48   
    4449#if ENABLE(JIT)
    4550

  • trunk/Source/JavaScriptCore/llint/LLIntThunks.h

    r204912 r205330  
    3939}
    4040
     41EncodedJSValue JS_EXPORT_PRIVATE vmEntryToWASM(void*, VM*, ProtoCallFrame*);
     42
    4143namespace LLInt {
    4244

  • trunk/Source/JavaScriptCore/testWASM.cpp

    r204484 r205330  
    2828#include "B3Compilation.h"
    2929#include "InitializeThreading.h"
     30#include "JSCJSValueInlines.h"
    3031#include "JSString.h"
     32#include "LLIntThunks.h"
     33#include "ProtoCallFrame.h"
    3134#include "VM.h"
    3235#include "WASMPlan.h"
    … …  
    191194using namespace B3;
    192195
    193 template<typename T, typename... Arguments>
    194 T invoke(MacroAssemblerCodePtr ptr, Arguments... arguments)
    195 {
    196     T (*function)(Arguments...) = bitwise_cast<T(*)(Arguments...)>(ptr.executableAddress());
    197     return function(arguments...);
    198 }
    199 
    200 template<typename T, typename... Arguments>
    201 T invoke(const Compilation& code, Arguments... arguments)
    202 {
    203     return invoke<T>(code.code(), arguments...);
     196template<typename T>
     197T invoke(MacroAssemblerCodePtr ptr, std::initializer_list<JSValue> args)
     198{
     199    JSValue firstArgument;
     200    // Since vmEntryToJavaScript expects a this value we claim there is one... there isn't.
     201    int argCount = 1;
     202    JSValue* remainingArguments = nullptr;
     203    if (args.size()) {
     204        remainingArguments = const_cast<JSValue*>(args.begin());
     205        firstArgument = *remainingArguments;
     206        remainingArguments++;
     207        argCount = args.size();
     208    }
     209
     210    ProtoCallFrame protoCallFrame;
     211    protoCallFrame.init(nullptr, nullptr, firstArgument, argCount, remainingArguments);
     212
     213    // This won't work for floating point values but we don't have those yet.
     214    return static_cast<T>(vmEntryToWASM(ptr.executableAddress(), vm, &protoCallFrame));
     215}
     216
     217template<typename T>
     218T invoke(const Compilation& code, std::initializer_list<JSValue> args)
     219{
     220    return invoke<T>(code.code(), args);
     221}
     222
     223inline JSValue box(uint64_t value)
     224{
     225    return JSValue::decode(value);
    204226}
    205227
    … …  
    225247
    226248        // Test this doesn't crash.
    227         RELEASE_ASSERT(invoke<int>(*plan.result[0]) == 5);
     249        RELEASE_ASSERT(invoke<int>(*plan.result[0], { }) == 5);
    228250    }
    229251
    … …  
    247269
    248270        // Test this doesn't crash.
    249         RELEASE_ASSERT(invoke<int>(*plan.result[0]) == 11);
     271        RELEASE_ASSERT(invoke<int>(*plan.result[0], { }) == 11);
    250272    }
    251273   
    … …  
    268290
    269291        // Test this doesn't crash.
    270         RELEASE_ASSERT(invoke<int>(*plan.result[0]) == 11);
     292        RELEASE_ASSERT(invoke<int>(*plan.result[0], { }) == 11);
    271293    }
    272294
    … …  
    289311
    290312        // Test this doesn't crash.
    291         RELEASE_ASSERT(invoke<int>(*plan.result[0]) == 11);
     313        RELEASE_ASSERT(invoke<int>(*plan.result[0], { }) == 11);
     314    }
     315
     316    {
     317        // Generated from: (module (func $add (param $x i32) (param $y i32) (result i32) (return (i32.add (get_local $x) (get_local $y)))) )
     318        Vector<uint8_t> vector = {
     319            0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x04, 0x74, 0x79, 0x70, 0x65, 0x87, 0x80, 0x80,
     320            0x00, 0x01, 0x40, 0x02, 0x01, 0x01, 0x01, 0x01, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
     321            0x6e, 0x82, 0x80, 0x80, 0x00, 0x01, 0x00, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x8e, 0x80, 0x80, 0x00,
     322            0x01, 0x89, 0x80, 0x80, 0x00, 0x00, 0x14, 0x00, 0x14, 0x01, 0x40, 0x09, 0x01, 0x0f
     323        };
     324
     325        Plan plan(*vm, vector);
     326        if (plan.result.size() != 1 || !plan.result[0]) {
     327            dataLogLn("Module failed to compile correctly.");
     328            CRASH();
     329        }
     330
     331        // Test this doesn't crash.
     332        RELEASE_ASSERT(invoke<int>(*plan.result[0], {box(0), box(1)}) == 1);
     333        RELEASE_ASSERT(invoke<int>(*plan.result[0], {box(100), box(1)}) == 101);
     334        RELEASE_ASSERT(invoke<int>(*plan.result[0], {box(-1), box(1)}) == 0);
     335        RELEASE_ASSERT(invoke<int>(*plan.result[0], {box(std::numeric_limits<int>::max()), box(1)}) == std::numeric_limits<int>::min());
    292336    }
    293337}

  • trunk/Source/JavaScriptCore/wasm/WASMB3IRGenerator.cpp

    r205309 r205330  
    3030
    3131#include "B3BasicBlockInlines.h"
     32#include "B3CallingConventions.h"
    3233#include "B3ValueInlines.h"
    3334#include "B3Variable.h"
    3435#include "B3VariableValue.h"
     36#include "VirtualRegister.h"
    3537#include "WASMFunctionParser.h"
    3638#include <wtf/Optional.h>
    … …  
    6870    B3IRGenerator(Procedure&);
    6971
     72    void addArguments(const Vector<Type>&);
    7073    void addLocal(Type, uint32_t);
    7174    ExpressionType addConstant(Type, uint64_t);
     75
     76    bool WARN_UNUSED_RETURN getLocal(uint32_t index, ExpressionType& result);
    7277
    7378    bool WARN_UNUSED_RETURN binaryOp(BinaryOpType, ExpressionType left, ExpressionType right, ExpressionType& result);
    … …  
    8994    // This is a pair of the continuation and the types expected on the stack for that continuation.
    9095    Vector<std::pair<BasicBlock*, Optional<Vector<Variable*>>>> m_controlStack;
     96    Vector<Variable*> m_locals;
    9197};
    9298
    … …  
    97103}
    98104
    99 void B3IRGenerator::addLocal(Type, uint32_t)
     105void B3IRGenerator::addLocal(Type type, uint32_t count)
     106{
     107    m_locals.reserveCapacity(m_locals.size() + count);
     108    for (uint32_t i = 0; i < count; ++i)
     109        m_locals.append(m_proc.addVariable(type));
     110}
     111
     112void B3IRGenerator::addArguments(const Vector<Type>& types)
    100113{
    101114    // TODO: Add locals.
     115    ASSERT(!m_locals.size());
     116    m_locals.grow(types.size());
     117    jscCallingConvention().iterate(types, m_proc, m_currentBlock, Origin(),
     118        [&] (ExpressionType argument, unsigned i) {
     119            Variable* argumentVariable = m_proc.addVariable(argument->type());
     120            m_locals[i] = argumentVariable;
     121            m_currentBlock->appendNew<VariableValue>(m_proc, Set, Origin(), argumentVariable, argument);
     122        });
     123}
     124
     125bool WARN_UNUSED_RETURN B3IRGenerator::getLocal(uint32_t index, ExpressionType& result)
     126{
     127    ASSERT(m_locals[index]);
     128    result = m_currentBlock->appendNew<VariableValue>(m_proc, B3::Get, Origin(), m_locals[index]);
     129    return true;
    102130}
    103131

  • trunk/Source/JavaScriptCore/wasm/WASMFormat.h

    r205309 r205330  
    9191
    9292struct FunctionInformation {
     93    Signature* signature;
    9394    size_t start;
    9495    size_t end;

  • trunk/Source/JavaScriptCore/wasm/WASMFunctionParser.h

    r205309 r205330  
    6262    , m_context(context)
    6363{
     64    m_context.addArguments(info.signature->arguments);
    6465}
    6566
    … …  
    139140    }
    140141
     142    case OpType::GetLocal: {
     143        uint32_t index;
     144        if (!parseVarUInt32(index))
     145            return false;
     146        ExpressionType result;
     147        if (!m_context.getLocal(index, result))
     148            return false;
     149
     150        m_expressionStack.append(result);
     151        return true;
     152    }
     153
    141154    case OpType::Block: {
    142155        if (!m_context.addBlock())

  • trunk/Source/JavaScriptCore/wasm/WASMModuleParser.cpp

    r205309 r205330  
    141141        dataLogLn("count: ", count);
    142142
     143    m_signatures.resize(count);
     144
    143145    for (uint32_t i = 0; i < count; ++i) {
    144146        uint8_t type;
    … …  
    182184            returnType = Type::Void;
    183185
    184         // TODO: Actually do something with this data...
    185         UNUSED_PARAM(returnType);
     186        m_signatures[i] = { returnType, WTFMove(argumentTypes) };
    186187    }
    187188    return true;
    … …  
    200201        if (!parseVarUInt32(typeNumber))
    201202            return false;
     203
     204        if (typeNumber >= m_signatures.size())
     205            return false;
     206
     207        m_functions[i].signature = &m_signatures[typeNumber];
    202208    }
    203209

  • trunk/Source/JavaScriptCore/wasm/WASMModuleParser.h

    r205309 r205330  
    5959
    6060    Vector<FunctionInformation> m_functions;
     61    Vector<Signature> m_signatures;
    6162};
    6263

  • trunk/Source/JavaScriptCore/wasm/WASMOps.h

    r205309 r205330  
    3333
    3434#define FOR_EACH_WASM_SPECIAL_OP(macro) \
    35     macro(I32Const, 0x10, NA)
     35    macro(I32Const, 0x10, NA) \
     36    macro(GetLocal, 0x14, NA)
    3637
    3738#define FOR_EACH_WASM_CONTROL_FLOW_OP(macro) \
Note: See TracChangeset for help on using the changeset viewer.