Attachment #261087 for bug #149106

View Details Raw Unified Return to Bug 149106

| Differences between



            { "name" : "op_is_function", "length" : 3 },
            { "name" : "op_in", "length" : 4 },
            { "name" : "op_get_by_id", "length" : 9  },
            { "name" : "op_get_by_id_out_of_line", "length" : 9  },
            { "name" : "op_get_array_length", "length" : 9 },
            { "name" : "op_put_by_id", "length" : 9 },
            { "name" : "op_put_by_id_out_of_line", "length" : 9 },
            { "name" : "op_put_by_id_transition_direct", "length" : 9 },
            { "name" : "op_put_by_id_transition_direct_out_of_line", "length" : 9 },
            { "name" : "op_put_by_id_transition_normal", "length" : 9 },
            { "name" : "op_put_by_id_transition_normal_out_of_line", "length" : 9 },
            { "name" : "op_del_by_id", "length" : 4 },
            { "name" : "op_get_by_val", "length" : 6 },
            { "name" : "op_put_by_val", "length" : 5 },



    case op_get_by_id:
        op = "get_by_id";
        break;
    case op_get_by_id_out_of_line:
        op = "get_by_id_out_of_line";
        break;
    case op_get_array_length:
        op = "array_length";
        break;

    
    if (exec->interpreter()->getOpcodeID(instruction[0].u.opcode) == op_get_array_length)
        out.printf(" llint(array_length)");
    else if (StructureID structureID = instruction[4].u.structureID) {
        Structure* structure = m_vm->heap.structureIDTable().get(structureID);
        out.printf(" llint(");
        dumpStructure(out, "struct", structure, ident);
        out.printf(")");

    const Identifier& ident = identifier(instruction[2].u.operand);
    
    UNUSED_PARAM(ident); // tell the compiler to shut up in certain platform configurations.

    out.print(", ", instruction[8].u.putByIdFlags);
    
    if (StructureID structureID = instruction[4].u.structureID) {
        Structure* structure = m_vm->heap.structureIDTable().get(structureID);
        out.print(" llint(");
        if (StructureID newStructureID = instruction[6].u.structureID) {
            Structure* newStructure = m_vm->heap.structureIDTable().get(newStructureID);
            dumpStructure(out, "struct", structure, ident);
            out.print(")");
            break;
            
        case op_put_by_id_transition_direct:
        case op_put_by_id_transition_normal:
        case op_put_by_id_transition_direct_out_of_line:
        case op_put_by_id_transition_normal_out_of_line:
            out.print(" llint(");
            dumpStructure(out, "prev", structure, ident);
            out.print(", ");
            dumpStructure(out, "next", instruction[6].u.structure.get(), ident);

                out.print(", ");
                dumpChain(out, chain, ident);
            }
        } else
            dumpStructure(out, "struct", structure, ident);
        out.print(")");
        default:
            out.print(" llint(unknown)");
            break;
        }
    }

#if ENABLE(JIT)

            break;
        }
        case op_get_by_id:
        case op_get_by_id_out_of_line:
        case op_get_array_length: {
            printGetByIdOp(out, exec, location, it);
            printGetByIdCacheStatus(out, exec, location, stubInfos);

            printPutByIdCacheStatus(out, exec, location, stubInfos);
            break;
        }
        case op_put_by_id_out_of_line: {
            printPutByIdOp(out, exec, location, it, "put_by_id_out_of_line");
            printPutByIdCacheStatus(out, exec, location, stubInfos);
            break;
        }
        case op_put_by_id_transition_direct: {
            printPutByIdOp(out, exec, location, it, "put_by_id_transition_direct");
            printPutByIdCacheStatus(out, exec, location, stubInfos);
            break;
        }
        case op_put_by_id_transition_direct_out_of_line: {
            printPutByIdOp(out, exec, location, it, "put_by_id_transition_direct_out_of_line");
            printPutByIdCacheStatus(out, exec, location, stubInfos);
            break;
        }
        case op_put_by_id_transition_normal: {
            printPutByIdOp(out, exec, location, it, "put_by_id_transition_normal");
            printPutByIdCacheStatus(out, exec, location, stubInfos);
            break;
        }
        case op_put_by_id_transition_normal_out_of_line: {
            printPutByIdOp(out, exec, location, it, "put_by_id_transition_normal_out_of_line");
            printPutByIdCacheStatus(out, exec, location, stubInfos);
            break;
        }
        case op_put_getter_by_id: {
            int r0 = (++it)->u.operand;
            int id0 = (++it)->u.operand;

    for (size_t size = propertyAccessInstructions.size(), i = 0; i < size; ++i) {
        Instruction* curInstruction = &instructions()[propertyAccessInstructions[i]];
        switch (interpreter->getOpcodeID(curInstruction[0].u.opcode)) {
        case op_get_by_id: {
            StructureID oldStructureID = curInstruction[4].u.structureID;
            if (!oldStructureID || Heap::isMarked(m_vm->heap.structureIDTable().get(oldStructureID)))
        case op_put_by_id_out_of_line:
            if (!curInstruction[4].u.structure || Heap::isMarked(curInstruction[4].u.structure.get()))
                break;
            if (Options::verboseOSR())
                dataLogF("Clearing LLInt property access.\n");
            curInstruction[4].u.structureID = 0;
            curInstruction[5].u.operand = 0;
            break;
        }
        case op_put_by_id: {
            StructureID oldStructureID = curInstruction[4].u.structureID;
            StructureID newStructureID = curInstruction[6].u.structureID;
            StructureChain* chain = curInstrucxtion[7].u.structureChain.get();
            if ((!oldStructureID || Heap::isMarked(m_vm->heap.structureIDTable().get(oldStructureID))) &&
                (!newStructureID || Heap::isMarked(m_vm->heap.structureIDTable().get(newtructureID))) &&
                (!chain || Heap::isMarked(chain)))
                break;
            if (Options::verboseOSR())
                dataLogF("Clearing LLInt put transition.\n");
            curInstruction[4].u.structureID = 0;
            curInstruction[5].u.operand = 0;
            curInstruction[6].u.structureID = 0;
            curInstruction[4].u.structure.clear();
            curInstruction[6].u.structure.clear();
            curInstruction[7].u.structureChain.clear();
            curInstruction[0].u.opcode = interpreter->getOpcode(op_put_by_id);
            break;
        }
        case op_get_array_length:
            break;
        case op_to_this:

Lines 70-84 GetByIdStatus GetByIdStatus::computeFrom Source/JavaScriptCore/bytecode/GetByIdStatus.cpp_sec1
- Source/JavaScriptCore/bytecode/GetByIdStatus.cpp -2 / +7 lines
70	UNUSED_PARAM(profiledBlock);	70	UNUSED_PARAM(profiledBlock);
71	UNUSED_PARAM(bytecodeIndex);	71	UNUSED_PARAM(bytecodeIndex);
72	UNUSED_PARAM(uid);	72	UNUSED_PARAM(uid);
		73
		74	VM& vm = *profiledBlock->vm();
		75
73	Instruction* instruction = profiledBlock->instructions().begin() + bytecodeIndex;	76	Instruction* instruction = profiledBlock->instructions().begin() + bytecodeIndex;
74		77
75	if (instruction[0].u.opcode == LLInt::getOpcode(op_get_array_length))	78	if (instruction[0].u.opcode == LLInt::getOpcode(op_get_array_length))
76	return GetByIdStatus(NoInformation, false);	79	return GetByIdStatus(NoInformation, false);
77		80
78	Structure* structure = instruction[4].u.structure.get();	81	StructureID structureID = instruction[4].u.structureID;
79	if (!structure)	82	if (!structureID)
80	return GetByIdStatus(NoInformation, false);	83	return GetByIdStatus(NoInformation, false);
81		84
		85	Structure* structure = vm.heap.structureIDTable().get(structureID);
		86
82	if (structure->takesSlowPathInDFGForImpureProperty())	87	if (structure->takesSlowPathInDFGForImpureProperty())
83	return GetByIdStatus(NoInformation, false);	88	return GetByIdStatus(NoInformation, false);
84		89

Lines 32-37 Source/JavaScriptCore/bytecode/Instruction.h_sec1
- Source/JavaScriptCore/bytecode/Instruction.h +8 lines
32	#include "BasicBlockLocation.h"	32	#include "BasicBlockLocation.h"
33	#include "MacroAssembler.h"	33	#include "MacroAssembler.h"
34	#include "Opcode.h"	34	#include "Opcode.h"
		35	#include "PutByIdFlags.h"
35	#include "SymbolTable.h"	36	#include "SymbolTable.h"
36	#include "TypeLocation.h"	37	#include "TypeLocation.h"
37	#include "PropertySlot.h"	38	#include "PropertySlot.h"
Lines 75-80 struct Instruction { Source/JavaScriptCore/bytecode/Instruction.h_sec2
75	u.operand = operand;	76	u.operand = operand;
76	}	77	}
77		78
		79	Instruction(PutByIdFlags flags)
		80	{
		81	u.putByIdFlags = flags;
		82	}
		83
78	Instruction(VM& vm, JSCell* owner, Structure* structure)	84	Instruction(VM& vm, JSCell* owner, Structure* structure)
79	{	85	{
80	u.structure.clear();	86	u.structure.clear();
Lines 107-112 struct Instruction { Source/JavaScriptCore/bytecode/Instruction.h_sec3
107	Opcode opcode;	113	Opcode opcode;
108	int operand;	114	int operand;
109	WriteBarrierBase<Structure> structure;	115	WriteBarrierBase<Structure> structure;
		116	StructureID structureID;
110	WriteBarrierBase<SymbolTable> symbolTable;	117	WriteBarrierBase<SymbolTable> symbolTable;
111	WriteBarrierBase<StructureChain> structureChain;	118	WriteBarrierBase<StructureChain> structureChain;
112	WriteBarrierBase<JSCell> jsCell;	119	WriteBarrierBase<JSCell> jsCell;
Lines 125-130 struct Instruction { Source/JavaScriptCore/bytecode/Instruction.h_sec4
125	ToThisStatus toThisStatus;	132	ToThisStatus toThisStatus;
126	TypeLocation* location;	133	TypeLocation* location;
127	BasicBlockLocation* basicBlockLocation;	134	BasicBlockLocation* basicBlockLocation;
		135	PutByIdFlags putByIdFlags;
128	} u;	136	} u;
129		137
130	private:	138	private:



/*
 * Copyright (C) 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "PutByIdFlags.h"

#include <wtf/CommaPrinter.h>
#include <wtf/PrintStream.h>
#include <wtf/StringPrintStream.h>

namespace WTF {

using namespace JSC;

void printInternal(PrintStream& out, PutByIdFlags flags) {
    StringPrintStream stringOut;
    CommaPrinter comma("|");
    if (flags & IsDirect)
        stringOut.print(comma, "IsDirect");

    CString string = stringOut.toCString();
    if (!string.length())
        out.print("None");
    else
        out.print(string);
}

} // namespace WTF




/*
 * Copyright (C) 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#ifndef PutByIdFlags_h
#define PutByIdFlags_h

namespace JSC {

enum class PutByIdFlags {
    None = 0,
    IsDirect = 1
};

} // namespace JSC

namespace WTF {

class PrintStream;

void printInternal(PrintStream&, JSC::PutByIdFlags);

} // namespace WTF

#endif // PutByIdFlags_h


Lines 66-102 PutByIdStatus PutByIdStatus::computeFrom Source/JavaScriptCore/bytecode/PutByIdStatus.cpp_sec1
- Source/JavaScriptCore/bytecode/PutByIdStatus.cpp -13 / +12 lines
66	UNUSED_PARAM(profiledBlock);	66	UNUSED_PARAM(profiledBlock);
67	UNUSED_PARAM(bytecodeIndex);	67	UNUSED_PARAM(bytecodeIndex);
68	UNUSED_PARAM(uid);	68	UNUSED_PARAM(uid);
		69
		70	VM& vm = *profiledBlock->vm();
		71
69	Instruction* instruction = profiledBlock->instructions().begin() + bytecodeIndex;	72	Instruction* instruction = profiledBlock->instructions().begin() + bytecodeIndex;
70		73
71	Structure* structure = instruction[4].u.structure.get();	74	StructureID structureID = instruction[4].u.structureID;
72	if (!structure)	75	if (!structureID)
73	return PutByIdStatus(NoInformation);	76	return PutByIdStatus(NoInformation);
74		77
75	if (instruction[0].u.opcode == LLInt::getOpcode(op_put_by_id)	78	Structure* structure = vm.heap.structureIDTable().get(structureID);
76	\|\| instruction[0].u.opcode == LLInt::getOpcode(op_put_by_id_out_of_line)) {	79
		80	StructureID newStructureID = instruction[6].u.structureID;
		81	if (!newStructureID) {
77	PropertyOffset offset = structure->getConcurrently(uid);	82	PropertyOffset offset = structure->getConcurrently(uid);
78	if (!isValidOffset(offset))	83	if (!isValidOffset(offset))
79	return PutByIdStatus(NoInformation);	84	return PutByIdStatus(NoInformation);
80		85
81	return PutByIdVariant::replace(structure, offset);	86	return PutByIdVariant::replace(structure, offset);
82	}	87	}
		88
		89	Structure* newStructure = vm.heap.structureIDTable().get(newStructureID);
83		90
84	ASSERT(structure->transitionWatchpointSetHasBeenInvalidated());	91	ASSERT(structure->transitionWatchpointSetHasBeenInvalidated());
85		92
86	ASSERT(instruction[0].u.opcode == LLInt::getOpcode(op_put_by_id_transition_direct)
87	\|\| instruction[0].u.opcode == LLInt::getOpcode(op_put_by_id_transition_normal)
88	\|\| instruction[0].u.opcode == LLInt::getOpcode(op_put_by_id_transition_direct_out_of_line)
89	\|\| instruction[0].u.opcode == LLInt::getOpcode(op_put_by_id_transition_normal_out_of_line));
90
91	Structure* newStructure = instruction[6].u.structure.get();
92
93	PropertyOffset offset = newStructure->getConcurrently(uid);	93	PropertyOffset offset = newStructure->getConcurrently(uid);
94	if (!isValidOffset(offset))	94	if (!isValidOffset(offset))
95	return PutByIdStatus(NoInformation);	95	return PutByIdStatus(NoInformation);
96		96
97	ObjectPropertyConditionSet conditionSet;	97	ObjectPropertyConditionSet conditionSet;
98	if (instruction[0].u.opcode == LLInt::getOpcode(op_put_by_id_transition_normal)	98	if (!(instructions[8].u.putByIdFlags & PutByIdFlags::IsDirect)) {
99	\|\| instruction[0].u.opcode == LLInt::getOpcode(op_put_by_id_transition_normal_out_of_line)) {
100	conditionSet =	99	conditionSet =
101	generateConditionsForPropertySetterMissConcurrently(	100	generateConditionsForPropertySetterMissConcurrently(
102	*profiledBlock->vm(), profiledBlock->globalObject(), structure, uid);	101	*profiledBlock->vm(), profiledBlock->globalObject(), structure, uid);



#include "JSCell.h"
#include "JSString.h"
#include "ParserModes.h"
#include "PutByIdFlags.h"
#include "RegExp.h"
#include "SpecialPointer.h"
#include "UnlinkedFunctionExecutable.h"

    UnlinkedInstruction() { u.operand = 0; }
    UnlinkedInstruction(OpcodeID opcode) { u.opcode = opcode; }
    UnlinkedInstruction(int operand) { u.operand = operand; }
    UnlinkedInstruction(PutByIdFlags flags) { u.putByIdFlags = flags; }
    union {
        OpcodeID opcode;
        int32_t operand;
        unsigned index;
        PutByIdFlags putByIdFlags;
    } u;
};




    instructions().append(base->index());
    instructions().append(propertyIndex);
    instructions().append(value->index());
    instructions().append(0); // old structure
    instructions().append(0); // offset
    instructions().append(0); // new structure
    instructions().append(0); // structure chain
    instructions().append(PutByIdFlags::None); // is not direct

    return value;
}

    instructions().append(base->index());
    instructions().append(propertyIndex);
    instructions().append(value->index());
    instructions().append(0); // old structure
    instructions().append(0); // offset
    instructions().append(0); // new structure
    instructions().append(0); // structure chain (unused if direct)
    instructions().append((putType == PropertyNode::KnownDirect || property != m_vm->propertyNames->underscoreProto) ? PutByIdFlags::IsDirect : PutByIdFlags::None);
    return value;
}




                // Figure out what the result is going to be - is it TOP, a constant, or maybe
                // something more subtle?
                AbstractValue result;
                if (m_state.structureClobberState() == StructuresAreWatched) {
                    for (unsigned i = status.numVariants(); i--;) {
                        // This thing won't give us a variant that involves prototypes. If it
                        // did, we'd have more work to do here.
                        DFG_ASSERT(m_graph, node, status[i].conditionSet().isEmpty());
                    
                        JSValue constantResult =
                            m_graph.tryGetConstantProperty(value, status[i].offset());
                        if (!constantResult) {
                            result.makeHeapTop();
                            break;
                        }
                    
                        AbstractValue thisResult;
                        thisResult.set(
                            m_graph, *m_graph.freeze(constantResult),
                            m_state.structureClobberState());
                        result.merge(thisResult);
                    }
                } else
                    result.makeHeapTop();
                if (status.numVariants() == 1 || isFTL(m_graph.m_plan.mode))
                    m_state.setFoundConstants(true);
                forNode(node) = result;

                result.makeHeapTop();
                continue;
            }

            // We can fold constants here regardless of the structure clobber state because this
            // node will still return the constant even if some watchpoints fired.
            
            AbstractValue thisResult;
            thisResult.set(



        }
            
        case op_get_by_id:
        case op_get_by_id_out_of_line:
        case op_get_array_length: {
            SpeculatedType prediction = getPrediction();
            


            NEXT_OPCODE(op_get_by_id);
        }
        case op_put_by_id: {
        case op_put_by_id_out_of_line:
        case op_put_by_id_transition_direct:
        case op_put_by_id_transition_normal:
        case op_put_by_id_transition_direct_out_of_line:
        case op_put_by_id_transition_normal_out_of_line: {
            Node* value = get(VirtualRegister(currentInstruction[3].u.operand));
            Node* base = get(VirtualRegister(currentInstruction[1].u.operand));
            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[currentInstruction[2].u.operand];
            bool direct = currentInstruction[8].u.putByIdFlags & PutByIdFalgs::IsDirect;

            PutByIdStatus putByIdStatus = PutByIdStatus::computeFor(
                m_inlineStackTop->m_profiledBlock, m_dfgCodeBlock,



    case op_put_by_val:
    case op_put_by_val_direct:
    case op_get_by_id:
    case op_get_by_id_out_of_line:
    case op_get_array_length:
    case op_put_by_id:
    case op_put_by_id_out_of_line:
    case op_put_by_id_transition_direct:
    case op_put_by_id_transition_direct_out_of_line:
    case op_put_by_id_transition_normal:
    case op_put_by_id_transition_normal_out_of_line:
    case op_jmp:
    case op_jtrue:
    case op_jfalse:



        DEFINE_OP(op_load_arrowfunction_this)
        DEFINE_OP(op_eq)
        DEFINE_OP(op_eq_null)
        case op_get_by_id_out_of_line:
        case op_get_array_length:
        DEFINE_OP(op_get_by_id)
        DEFINE_OP(op_get_by_val)

        DEFINE_OP(op_push_with_scope)
        DEFINE_OP(op_create_lexical_environment)
        DEFINE_OP(op_get_parent_scope)
        case op_put_by_id_out_of_line:
        case op_put_by_id_transition_direct:
        case op_put_by_id_transition_normal:
        case op_put_by_id_transition_direct_out_of_line:
        case op_put_by_id_transition_normal_out_of_line:
        DEFINE_OP(op_put_by_id)
        DEFINE_OP(op_put_by_index)
        case op_put_by_val_direct:

Lines 623-629 void JIT::emit_op_put_by_id(Instruction* Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp_sec1
- Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp -1 / +1 lines
623		623
624	int base = currentInstruction[1].u.operand;	624	int base = currentInstruction[1].u.operand;
625	int value = currentInstruction[3].u.operand;	625	int value = currentInstruction[3].u.operand;
626	int direct = currentInstruction[8].u.operand;	626	int direct = currentInstruction[8].u.putByIdFlags & PutByIdFlags::IsDirect;
627		627
628	emitWriteBarrier(base, value, ShouldFilterBase);	628	emitWriteBarrier(base, value, ShouldFilterBase);
629		629

Lines 607-613 void JIT::emit_op_put_by_id(Instruction* Source/JavaScriptCore/jit/JITPropertyAccess.cpp_sec1
- Source/JavaScriptCore/jit/JITPropertyAccess.cpp -1 / +1 lines
607	{	607	{
608	int baseVReg = currentInstruction[1].u.operand;	608	int baseVReg = currentInstruction[1].u.operand;
609	int valueVReg = currentInstruction[3].u.operand;	609	int valueVReg = currentInstruction[3].u.operand;
610	unsigned direct = currentInstruction[8].u.operand;	610	unsigned direct = currentInstruction[8].u.putByIdFlags & PutByIdFlags::IsDirect;
611		611
612	emitWriteBarrier(baseVReg, valueVReg, ShouldFilterBase);	612	emitWriteBarrier(baseVReg, valueVReg, ShouldFilterBase);
613		613

Lines 570-589 LLINT_SLOW_PATH_DECL(slow_path_get_by_id Source/JavaScriptCore/llint/LLIntSlowPaths.cpp_sec1
- Source/JavaScriptCore/llint/LLIntSlowPaths.cpp -46 / +27 lines
570	JSCell* baseCell = baseValue.asCell();	570	JSCell* baseCell = baseValue.asCell();
571	Structure* structure = baseCell->structure();	571	Structure* structure = baseCell->structure();
572		572
		573	// Start out by clearing out the old cache.
		574	op[4].u.pointer = nullptr; // old structure
		575	op[5].u.pointer = nullptr; // offset
		576
573	if (!structure->isUncacheableDictionary()	577	if (!structure->isUncacheableDictionary()
574	&& !structure->typeInfo().prohibitsPropertyCaching()	578	&& !structure->typeInfo().prohibitsPropertyCaching()
575	&& !structure->typeInfo().newImpurePropertyFiresWatchpoints()) {	579	&& !structure->typeInfo().newImpurePropertyFiresWatchpoints()) {
		580	vm.heap.writeBarrier(codeBlock->ownerExecutable());
		581
576	ConcurrentJITLocker locker(codeBlock->m_lock);	582	ConcurrentJITLocker locker(codeBlock->m_lock);
577		583
578	pc[4].u.structure.set(	584	pc[4].u.structureID = structure->id();
579	vm, codeBlock->ownerExecutable(), structure);	585	pc[5].u.operand = slot.cachedOffset();
580	if (isInlineOffset(slot.cachedOffset())) {
581	pc[0].u.opcode = LLInt::getOpcode(op_get_by_id);
582	pc[5].u.operand = offsetInInlineStorage(slot.cachedOffset()) * sizeof(JSValue) + JSObject::offsetOfInlineStorage();
583	} else {
584	pc[0].u.opcode = LLInt::getOpcode(op_get_by_id_out_of_line);
585	pc[5].u.operand = offsetInButterfly(slot.cachedOffset()) * sizeof(JSValue);
586	}
587	}	586	}
588	}	587	}
589		588
Lines 618-624 LLINT_SLOW_PATH_DECL(slow_path_put_by_id Source/JavaScriptCore/llint/LLIntSlowPaths.cpp_sec2
618		617
619	JSValue baseValue = LLINT_OP_C(1).jsValue();	618	JSValue baseValue = LLINT_OP_C(1).jsValue();
620	PutPropertySlot slot(baseValue, codeBlock->isStrictMode(), codeBlock->putByIdContext());	619	PutPropertySlot slot(baseValue, codeBlock->isStrictMode(), codeBlock->putByIdContext());
621	if (pc[8].u.operand)	620	if (pc[8].u.putByIdFlags & PutByIdFlags::IsDirect)
622	asObject(baseValue)->putDirect(vm, ident, LLINT_OP_C(3).jsValue(), slot);	621	asObject(baseValue)->putDirect(vm, ident, LLINT_OP_C(3).jsValue(), slot);
623	else	622	else
624	baseValue.put(exec, ident, LLINT_OP_C(3).jsValue(), slot);	623	baseValue.put(exec, ident, LLINT_OP_C(3).jsValue(), slot);
Lines 627-632 LLINT_SLOW_PATH_DECL(slow_path_put_by_id Source/JavaScriptCore/llint/LLIntSlowPaths.cpp_sec3
627	if (!LLINT_ALWAYS_ACCESS_SLOW	626	if (!LLINT_ALWAYS_ACCESS_SLOW
628	&& baseValue.isCell()	627	&& baseValue.isCell()
629	&& slot.isCacheablePut()) {	628	&& slot.isCacheablePut()) {
		629
		630	// Start out by clearing out the old cache.
		631	op[4].u.pointer = nullptr; // old structure
		632	op[5].u.pointer = nullptr; // offset
		633	op[6].u.pointer = nullptr; // new structure
		634	op[7].u.pointer = nullptr; // structure chain
630		635
631	JSCell* baseCell = baseValue.asCell();	636	JSCell* baseCell = baseValue.asCell();
632	Structure* structure = baseCell->structure();	637	Structure* structure = baseCell->structure();
Lines 634-639 LLINT_SLOW_PATH_DECL(slow_path_put_by_id Source/JavaScriptCore/llint/LLIntSlowPaths.cpp_sec4
634	if (!structure->isUncacheableDictionary()	639	if (!structure->isUncacheableDictionary()
635	&& !structure->typeInfo().prohibitsPropertyCaching()	640	&& !structure->typeInfo().prohibitsPropertyCaching()
636	&& baseCell == slot.base()) {	641	&& baseCell == slot.base()) {
		642
		643	vm.heap.writeBarrier(codeBlock->ownerExecutable());
637		644
638	if (slot.type() == PutPropertySlot::NewProperty) {	645	if (slot.type() == PutPropertySlot::NewProperty) {
639	GCSafeConcurrentJITLocker locker(codeBlock->m_lock, vm.heap);	646	GCSafeConcurrentJITLocker locker(codeBlock->m_lock, vm.heap);
Lines 641-689 LLINT_SLOW_PATH_DECL(slow_path_put_by_id Source/JavaScriptCore/llint/LLIntSlowPaths.cpp_sec5
641	if (!structure->isDictionary() && structure->previousID()->outOfLineCapacity() == structure->outOfLineCapacity()) {	648	if (!structure->isDictionary() && structure->previousID()->outOfLineCapacity() == structure->outOfLineCapacity()) {
642	ASSERT(structure->previousID()->transitionWatchpointSetHasBeenInvalidated());	649	ASSERT(structure->previousID()->transitionWatchpointSetHasBeenInvalidated());
643		650
644	// This is needed because some of the methods we call
645	// below may GC.
646	pc[0].u.opcode = LLInt::getOpcode(op_put_by_id);
647
648	if (normalizePrototypeChain(exec, structure) != InvalidPrototypeChain) {	651	if (normalizePrototypeChain(exec, structure) != InvalidPrototypeChain) {
649	ASSERT(structure->previousID()->isObject());	652	ASSERT(structure->previousID()->isObject());
650	pc[4].u.structure.set(	653	pc[4].u.structureID = structure->previousID()->id();
651	vm, codeBlock->ownerExecutable(), structure->previousID());	654	pc[5].u.operand = slot.cachedOffset();
652	if (isInlineOffset(slot.cachedOffset()))	655	pc[6].u.structureID = structure->id();
653	pc[5].u.operand = offsetInInlineStorage(slot.cachedOffset()) * sizeof(JSValue) + JSObject::offsetOfInlineStorage();	656	if (!(pc[8].u.putByIdFlags & PutByIdFlags::IsDirect)) {
654	else	657	StructureChain* chain = structure->prototypeChain(exec);
655	pc[5].u.operand = offsetInButterfly(slot.cachedOffset()) * sizeof(JSValue);	658	ASSERT(chain);
656	pc[6].u.structure.set(	659	pc[7].u.structureChain.set(
657	vm, codeBlock->ownerExecutable(), structure);	660	vm, codeBlock->ownerExecutable(), chain);
658	StructureChain* chain = structure->prototypeChain(exec);
659	ASSERT(chain);
660	pc[7].u.structureChain.set(
661	vm, codeBlock->ownerExecutable(), chain);
662
663	if (pc[8].u.operand) {
664	if (isInlineOffset(slot.cachedOffset()))
665	pc[0].u.opcode = LLInt::getOpcode(op_put_by_id_transition_direct);
666	else
667	pc[0].u.opcode = LLInt::getOpcode(op_put_by_id_transition_direct_out_of_line);
668	} else {
669	if (isInlineOffset(slot.cachedOffset()))
670	pc[0].u.opcode = LLInt::getOpcode(op_put_by_id_transition_normal);
671	else
672	pc[0].u.opcode = LLInt::getOpcode(op_put_by_id_transition_normal_out_of_line);
673	}	661	}
674	}	662	}
675	}	663	}
676	} else {	664	} else {
677	structure->didCachePropertyReplacement(vm, slot.cachedOffset());	665	structure->didCachePropertyReplacement(vm, slot.cachedOffset());
678	pc[4].u.structure.set(	666	pc[4].u.structureID = structure->id();
679	vm, codeBlock->ownerExecutable(), structure);	667	pc[5].u.operand = slot.cachedOffset();
680	if (isInlineOffset(slot.cachedOffset())) {
681	pc[0].u.opcode = LLInt::getOpcode(op_put_by_id);
682	pc[5].u.operand = offsetInInlineStorage(slot.cachedOffset()) * sizeof(JSValue) + JSObject::offsetOfInlineStorage();
683	} else {
684	pc[0].u.opcode = LLInt::getOpcode(op_put_by_id_out_of_line);
685	pc[5].u.operand = offsetInButterfly(slot.cachedOffset()) * sizeof(JSValue);
686	}
687	}	668	}
688	}	669	}
689	}	670	}



    storeq value, ValueProfile::m_buckets[scratch]
end

macro structureIDToStructureWithScratch(structureID, structure, scratch)
end

macro loadStructureWithScratch(cell, structure, scratch)
    loadp CodeBlock[cfr], scratch
    loadp CodeBlock::m_vm[scratch], scratch
    loadp VM::heap + Heap::m_structureIDTable + StructureIDTable::m_table[scratch], scratch
    loadi structureID, structure
    loadp [scratch, structure, 8], structure
end

macro loadStructureWithScratch(cell, structure, scratch)
    structureIDToStructureWithScratch(JSCell::m_structureID[cell], structure, scratch)
end

macro loadStructureAndClobberFirstArg(cell, structure)
    loadi JSCell::m_structureID[cell], structure
    loadp CodeBlock[cfr], cell

    storeq value, (firstOutOfLineOffset - 2) * 8[objectAndStorage, propertyOffsetAsInt, 8]
end

_llint_op_get_by_id:
    traceExecution()
    # We only do monomorphic get_by_id caching for now, and we do not modify the
    # opcode. We do, however, allow for the cache to change anytime if fails, since
    # ping-ponging is free. At best we get lucky and the get_by_id will continue
    # to take fast path on the new cache. At worst we take slow path, which is what
    # we would have been doing anyway.
    loadisFromInstruction(2, t0)
    loadConstantOrVariableCell(t0, t3, .opGetByIdSlow)
    loadi JSCell::m_structureID[t3], t1
    loadisFromInstruction(4, t2)
    bineq t2, t1, .opGetByIdSlow
    loadisFromInstruction(5, t1)
    loadisFromInstruction(1, t2)
    loadPropertyAtVariableOffset(t1, t3, t0)
    storeq t0, [cfr, t2, 8]
    valueProfile(t0, 8, t1)
    dispatch(9)
            loadq [propertyStorage, t2], scratch
            storeq scratch, [cfr, t1, 8]
            valueProfile(scratch, 8, t1)
            dispatch(9)
        end)
            
    .opGetByIdSlow:
        callSlowPath(_llint_slow_path_get_by_id)
        dispatch(9)
end

_llint_op_get_by_id:
    getById(withInlineStorage)


.opGetByIdSlow:
    callSlowPath(_llint_slow_path_get_by_id)
    dispatch(9)


_llint_op_get_array_length:

    dispatch(9)


_llint_op_put_by_id:
    traceExecution()
    writeBarrierOnOperands(1, 3)
    loadisFromInstruction(1, t3)
    loadConstantOrVariableCell(t3, t0, .opPutByIdSlow)
    loadi JSCell::m_structureID[t0], t2
    loadisFromInstruction(4, t1)
    bineq t2, t1, .opPutByIdSlow

    # At this point, we have:
    # t1, t2 -> current structure ID
    # t0 -> object base
            loadisFromInstruction(5, t1)
            loadisFromInstruction(3, t2)
            loadConstantOrVariable(t2, scratch)
            storeq scratch, [propertyStorage, t1]
            dispatch(9)
        end)
end

_llint_op_put_by_id:
    putById(withInlineStorage)

    loadisFromInstruction(6, t1)
    
    btiz t1, .opPutByIdNotTransition

    # This is the transition case. t1 holds the new structureID. t2 holds the old structure ID.
    # If we have a chain, we need to check it. t0 is the base. We may clobber t1 to use it as
    # scratch.
    loadpFromInstruction(7, t3)
    btpz t3, .opPutByIdTransitionDirect

    loadp StructureChain::m_vector[t3], t3
    assert(macro (ok) btpnz t3, ok end)

    structureIDToStructureWithScratch(t2, t2, t1)
    loadq Structure::m_prototype[t2], t2
    bqeq t2, ValueNull, .opPutByIdTransitionChainDone
.opPutByIdTransitionChainLoop:
    loadStructureAndClobberFirstArg(t2, t1)
    move t1, t2
    bpneq t2, [t3], .opPutByIdSlot
    addp 8, t3
    loadq Structure::m_prototype[t2], t2
    bqneq t2, ValueNull, .opPutByIdTransitionChainLoop

.opPutByIdTransitionChainDone:
    # Reload the new structure, since we clobbered it above.
    loadisFromInstruction(6, t1)

.opPutByIdTransitionDirect:
    storei t1, JSCell::m_structureID[t0]

.opPutByIdNotTransition:
    # The only thing live right now is t0, which holds the base.
    loadisFromInstruction(3, t1)
    loadConstantOrVariable(t1, t2)
    loadpFromInstruction(4, t1)
    loadConstantOrVariableCell(t3, t0, .opPutByIdSlow)
    loadStructureWithScratch(t0, t2, t3)
    bpneq t2, t1, .opPutByIdSlow
    additionalChecks(t1, t3, t2)
    loadisFromInstruction(3, t2)
    loadisFromInstruction(5, t1)
    storePropertyAtVariableOffset(t1, t0, t2)
    dispatch(9)
        t3,
        macro (propertyStorage, scratch)
            addp t1, propertyStorage, t3
            loadConstantOrVariable(t2, t1)
            storeq t1, [t3]
            loadpFromInstruction(6, t1)
            loadi Structure::m_blob + StructureIDBlob::u.words.word1[t1], t1
            storei t1, JSCell::m_structureID[t0]
            dispatch(9)
        end)
end

macro noAdditionalChecks(oldStructure, scratch, scratch2)
end

macro structureChainChecks(oldStructure, scratch, scratch2)
    const protoCell = oldStructure    # Reusing the oldStructure register for the proto
    loadpFromInstruction(7, scratch)
    assert(macro (ok) btpnz scratch, ok end)
    loadp StructureChain::m_vector[scratch], scratch
    assert(macro (ok) btpnz scratch, ok end)
    bqeq Structure::m_prototype[oldStructure], ValueNull, .done
.loop:
    loadq Structure::m_prototype[oldStructure], protoCell
    loadStructureAndClobberFirstArg(protoCell, scratch2)
    move scratch2, oldStructure
    bpneq oldStructure, [scratch], .opPutByIdSlow
    addp 8, scratch
    bqneq Structure::m_prototype[oldStructure], ValueNull, .loop
.done:
end

_llint_op_put_by_id_transition_direct:
    putByIdTransition(noAdditionalChecks, withInlineStorage)


_llint_op_put_by_id_transition_direct_out_of_line:
    putByIdTransition(noAdditionalChecks, withOutOfLineStorage)


_llint_op_put_by_id_transition_normal:
    putByIdTransition(structureChainChecks, withInlineStorage)


.opPutByIdSlow:
    callSlowPath(_llint_slow_path_put_by_id)
    dispatch(9)


_llint_op_get_by_val:

Return to Bug 149106

Lines 273-281 void CodeBlock::printGetByIdOp(PrintStre Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec1
- Source/JavaScriptCore/bytecode/CodeBlock.cpp -75 / +32 lines
273	case op_get_by_id:	273	case op_get_by_id:
274	op = "get_by_id";	274	op = "get_by_id";
275	break;	275	break;
276	case op_get_by_id_out_of_line:
277	op = "get_by_id_out_of_line";
278	break;
279	case op_get_array_length:	276	case op_get_array_length:
280	op = "array_length";	277	op = "array_length";
281	break;	278	break;
Lines 331-337 void CodeBlock::printGetByIdCacheStatus( Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec2
331		328
332	if (exec->interpreter()->getOpcodeID(instruction[0].u.opcode) == op_get_array_length)	329	if (exec->interpreter()->getOpcodeID(instruction[0].u.opcode) == op_get_array_length)
333	out.printf(" llint(array_length)");	330	out.printf(" llint(array_length)");
334	else if (Structure* structure = instruction[4].u.structure.get()) {	331	else if (StructureID structureID = instruction[4].u.structureID) {
		332	Structure* structure = m_vm->heap.structureIDTable().get(structureID);
335	out.printf(" llint(");	333	out.printf(" llint(");
336	dumpStructure(out, "struct", structure, ident);	334	dumpStructure(out, "struct", structure, ident);
337	out.printf(")");	335	out.printf(")");
Lines 389-409 void CodeBlock::printPutByIdCacheStatus( Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec3
389	const Identifier& ident = identifier(instruction[2].u.operand);	387	const Identifier& ident = identifier(instruction[2].u.operand);
390		388
391	UNUSED_PARAM(ident); // tell the compiler to shut up in certain platform configurations.	389	UNUSED_PARAM(ident); // tell the compiler to shut up in certain platform configurations.
		390
		391	out.print(", ", instruction[8].u.putByIdFlags);
392		392
393	if (Structure* structure = instruction[4].u.structure.get()) {	393	if (StructureID structureID = instruction[4].u.structureID) {
394	switch (exec->interpreter()->getOpcodeID(instruction[0].u.opcode)) {	394	Structure* structure = m_vm->heap.structureIDTable().get(structureID);
395	case op_put_by_id:	395	out.print(" llint(");
396	case op_put_by_id_out_of_line:	396	if (StructureID newStructureID = instruction[6].u.structureID) {
397	out.print(" llint(");	397	Structure* newStructure = m_vm->heap.structureIDTable().get(newStructureID);
398	dumpStructure(out, "struct", structure, ident);
399	out.print(")");
400	break;
401
402	case op_put_by_id_transition_direct:
403	case op_put_by_id_transition_normal:
404	case op_put_by_id_transition_direct_out_of_line:
405	case op_put_by_id_transition_normal_out_of_line:
406	out.print(" llint(");
407	dumpStructure(out, "prev", structure, ident);	398	dumpStructure(out, "prev", structure, ident);
408	out.print(", ");	399	out.print(", ");
409	dumpStructure(out, "next", instruction[6].u.structure.get(), ident);	400	dumpStructure(out, "next", instruction[6].u.structure.get(), ident);
Lines 411-423 void CodeBlock::printPutByIdCacheStatus( Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec4
411	out.print(", ");	402	out.print(", ");
412	dumpChain(out, chain, ident);	403	dumpChain(out, chain, ident);
413	}	404	}
414	out.print(")");	405	} else
415	break;	406	dumpStructure(out, "struct", structure, ident);
416		407	out.print(")");
417	default:
418	out.print(" llint(unknown)");
419	break;
420	}
421	}	408	}
422		409
423	#if ENABLE(JIT)	410	#if ENABLE(JIT)
Lines 1001-1007 void CodeBlock::dumpBytecode( Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec5
1001	break;	988	break;
1002	}	989	}
1003	case op_get_by_id:	990	case op_get_by_id:
1004	case op_get_by_id_out_of_line:
1005	case op_get_array_length: {	991	case op_get_array_length: {
1006	printGetByIdOp(out, exec, location, it);	992	printGetByIdOp(out, exec, location, it);
1007	printGetByIdCacheStatus(out, exec, location, stubInfos);	993	printGetByIdCacheStatus(out, exec, location, stubInfos);
Lines 1013-1043 void CodeBlock::dumpBytecode( Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec6
1013	printPutByIdCacheStatus(out, exec, location, stubInfos);	999	printPutByIdCacheStatus(out, exec, location, stubInfos);
1014	break;	1000	break;
1015	}	1001	}
1016	case op_put_by_id_out_of_line: {
1017	printPutByIdOp(out, exec, location, it, "put_by_id_out_of_line");
1018	printPutByIdCacheStatus(out, exec, location, stubInfos);
1019	break;
1020	}
1021	case op_put_by_id_transition_direct: {
1022	printPutByIdOp(out, exec, location, it, "put_by_id_transition_direct");
1023	printPutByIdCacheStatus(out, exec, location, stubInfos);
1024	break;
1025	}
1026	case op_put_by_id_transition_direct_out_of_line: {
1027	printPutByIdOp(out, exec, location, it, "put_by_id_transition_direct_out_of_line");
1028	printPutByIdCacheStatus(out, exec, location, stubInfos);
1029	break;
1030	}
1031	case op_put_by_id_transition_normal: {
1032	printPutByIdOp(out, exec, location, it, "put_by_id_transition_normal");
1033	printPutByIdCacheStatus(out, exec, location, stubInfos);
1034	break;
1035	}
1036	case op_put_by_id_transition_normal_out_of_line: {
1037	printPutByIdOp(out, exec, location, it, "put_by_id_transition_normal_out_of_line");
1038	printPutByIdCacheStatus(out, exec, location, stubInfos);
1039	break;
1040	}
1041	case op_put_getter_by_id: {	1002	case op_put_getter_by_id: {
1042	int r0 = (++it)->u.operand;	1003	int r0 = (++it)->u.operand;
1043	int id0 = (++it)->u.operand;	1004	int id0 = (++it)->u.operand;
Lines 2553-2588 void CodeBlock::finalizeLLIntInlineCache Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec7
2553	for (size_t size = propertyAccessInstructions.size(), i = 0; i < size; ++i) {	2514	for (size_t size = propertyAccessInstructions.size(), i = 0; i < size; ++i) {
2554	Instruction* curInstruction = &instructions()[propertyAccessInstructions[i]];	2515	Instruction* curInstruction = &instructions()[propertyAccessInstructions[i]];
2555	switch (interpreter->getOpcodeID(curInstruction[0].u.opcode)) {	2516	switch (interpreter->getOpcodeID(curInstruction[0].u.opcode)) {
2556	case op_get_by_id:	2517	case op_get_by_id: {
2557	case op_get_by_id_out_of_line:	2518	StructureID oldStructureID = curInstruction[4].u.structureID;
2558	case op_put_by_id:	2519	if (!oldStructureID \|\| Heap::isMarked(m_vm->heap.structureIDTable().get(oldStructureID)))
2559	case op_put_by_id_out_of_line:
2560	if (!curInstruction[4].u.structure \|\| Heap::isMarked(curInstruction[4].u.structure.get()))
2561	break;	2520	break;
2562	if (Options::verboseOSR())	2521	if (Options::verboseOSR())
2563	dataLogF("Clearing LLInt property access with structure %p.\n", curInstruction[4].u.structure.get());	2522	dataLogF("Clearing LLInt property access.\n");
2564	curInstruction[4].u.structure.clear();	2523	curInstruction[4].u.structureID = 0;
2565	curInstruction[5].u.operand = 0;	2524	curInstruction[5].u.operand = 0;
2566	break;	2525	break;
2567	case op_put_by_id_transition_direct:	2526	}
2568	case op_put_by_id_transition_normal:	2527	case op_put_by_id: {
2569	case op_put_by_id_transition_direct_out_of_line:	2528	StructureID oldStructureID = curInstruction[4].u.structureID;
2570	case op_put_by_id_transition_normal_out_of_line:	2529	StructureID newStructureID = curInstruction[6].u.structureID;
2571	if (Heap::isMarked(curInstruction[4].u.structure.get())	2530	StructureChain* chain = curInstrucxtion[7].u.structureChain.get();
2572	&& Heap::isMarked(curInstruction[6].u.structure.get())	2531	if ((!oldStructureID \|\| Heap::isMarked(m_vm->heap.structureIDTable().get(oldStructureID))) &&
2573	&& Heap::isMarked(curInstruction[7].u.structureChain.get()))	2532	(!newStructureID \|\| Heap::isMarked(m_vm->heap.structureIDTable().get(newtructureID))) &&
2574	break;	2533	(!chain \|\| Heap::isMarked(chain)))
2575	if (Options::verboseOSR()) {	2534	break;
2576	dataLogF("Clearing LLInt put transition with structures %p -> %p, chain %p.\n",	2535	if (Options::verboseOSR())
2577	curInstruction[4].u.structure.get(),	2536	dataLogF("Clearing LLInt put transition.\n");
2578	curInstruction[6].u.structure.get(),	2537	curInstruction[4].u.structureID = 0;
2579	curInstruction[7].u.structureChain.get());	2538	curInstruction[5].u.operand = 0;
2580	}	2539	curInstruction[6].u.structureID = 0;
2581	curInstruction[4].u.structure.clear();
2582	curInstruction[6].u.structure.clear();
2583	curInstruction[7].u.structureChain.clear();	2540	curInstruction[7].u.structureChain.clear();
2584	curInstruction[0].u.opcode = interpreter->getOpcode(op_put_by_id);
2585	break;	2541	break;
		2542	}
2586	case op_get_array_length:	2543	case op_get_array_length:
2587	break;	2544	break;
2588	case op_to_this:	2545	case op_to_this:

Lines 2103-2113 RegisterID* BytecodeGenerator::emitPutBy Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp_sec1
- Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp -10 / +10 lines
2103	instructions().append(base->index());	2103	instructions().append(base->index());
2104	instructions().append(propertyIndex);	2104	instructions().append(propertyIndex);
2105	instructions().append(value->index());	2105	instructions().append(value->index());
2106	instructions().append(0);	2106	instructions().append(0); // old structure
2107	instructions().append(0);	2107	instructions().append(0); // offset
2108	instructions().append(0);	2108	instructions().append(0); // new structure
2109	instructions().append(0);	2109	instructions().append(0); // structure chain
2110	instructions().append(0);	2110	instructions().append(PutByIdFlags::None); // is not direct
2111		2111
2112	return value;	2112	return value;
2113	}	2113	}
Lines 2125-2135 RegisterID* BytecodeGenerator::emitDirec Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp_sec2
2125	instructions().append(base->index());	2125	instructions().append(base->index());
2126	instructions().append(propertyIndex);	2126	instructions().append(propertyIndex);
2127	instructions().append(value->index());	2127	instructions().append(value->index());
2128	instructions().append(0);	2128	instructions().append(0); // old structure
2129	instructions().append(0);	2129	instructions().append(0); // offset
2130	instructions().append(0);	2130	instructions().append(0); // new structure
2131	instructions().append(0);	2131	instructions().append(0); // structure chain (unused if direct)
2132	instructions().append(putType == PropertyNode::KnownDirect \|\| property != m_vm->propertyNames->underscoreProto);	2132	instructions().append((putType == PropertyNode::KnownDirect \|\| property != m_vm->propertyNames->underscoreProto) ? PutByIdFlags::IsDirect : PutByIdFlags::None);
2133	return value;	2133	return value;
2134	}	2134	}
2135		2135

Lines 1837-1860 bool AbstractInterpreter<AbstractStateTy Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h_sec1
- Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h -16 / +22 lines
1837	// Figure out what the result is going to be - is it TOP, a constant, or maybe	1837	// Figure out what the result is going to be - is it TOP, a constant, or maybe
1838	// something more subtle?	1838	// something more subtle?
1839	AbstractValue result;	1839	AbstractValue result;
1840	for (unsigned i = status.numVariants(); i--;) {	1840	if (m_state.structureClobberState() == StructuresAreWatched) {
1841	// This thing won't give us a variant that involves prototypes. If it did, we'd	1841	for (unsigned i = status.numVariants(); i--;) {
1842	// have more work to do here.	1842	// This thing won't give us a variant that involves prototypes. If it
1843	DFG_ASSERT(m_graph, node, status[i].conditionSet().isEmpty());	1843	// did, we'd have more work to do here.
		1844	DFG_ASSERT(m_graph, node, status[i].conditionSet().isEmpty());
1844		1845
1845	JSValue constantResult =	1846	JSValue constantResult =
1846	m_graph.tryGetConstantProperty(value, status[i].offset());	1847	m_graph.tryGetConstantProperty(value, status[i].offset());
1847	if (!constantResult) {	1848	if (!constantResult) {
1848	result.makeHeapTop();	1849	result.makeHeapTop();
1849	break;	1850	break;
1850	}	1851	}
1851		1852
1852	AbstractValue thisResult;	1853	AbstractValue thisResult;
1853	thisResult.set(	1854	thisResult.set(
1854	m_graph, *m_graph.freeze(constantResult),	1855	m_graph, *m_graph.freeze(constantResult),
1855	m_state.structureClobberState());	1856	m_state.structureClobberState());
1856	result.merge(thisResult);	1857	result.merge(thisResult);
1857	}	1858	}
		1859	} else
		1860	result.makeHeapTop();
1858	if (status.numVariants() == 1 \|\| isFTL(m_graph.m_plan.mode))	1861	if (status.numVariants() == 1 \|\| isFTL(m_graph.m_plan.mode))
1859	m_state.setFoundConstants(true);	1862	m_state.setFoundConstants(true);
1860	forNode(node) = result;	1863	forNode(node) = result;
Lines 2134-2139 bool AbstractInterpreter<AbstractStateTy Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h_sec2
2134	result.makeHeapTop();	2137	result.makeHeapTop();
2135	continue;	2138	continue;
2136	}	2139	}
		2140
		2141	// We can fold constants here regardless of the structure clobber state because this
		2142	// node will still return the constant even if some watchpoints fired.
2137		2143
2138	AbstractValue thisResult;	2144	AbstractValue thisResult;
2139	thisResult.set(	2145	thisResult.set(

Lines 3513-3519 bool ByteCodeParser::parseBlock(unsigned Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp_sec1
- Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp -8 / +2 lines
3513	}	3513	}
3514		3514
3515	case op_get_by_id:	3515	case op_get_by_id:
3516	case op_get_by_id_out_of_line:
3517	case op_get_array_length: {	3516	case op_get_array_length: {
3518	SpeculatedType prediction = getPrediction();	3517	SpeculatedType prediction = getPrediction();
3519		3518
Lines 3531-3546 bool ByteCodeParser::parseBlock(unsigned Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp_sec2
3531		3530
3532	NEXT_OPCODE(op_get_by_id);	3531	NEXT_OPCODE(op_get_by_id);
3533	}	3532	}
3534	case op_put_by_id:	3533	case op_put_by_id: {
3535	case op_put_by_id_out_of_line:
3536	case op_put_by_id_transition_direct:
3537	case op_put_by_id_transition_normal:
3538	case op_put_by_id_transition_direct_out_of_line:
3539	case op_put_by_id_transition_normal_out_of_line: {
3540	Node* value = get(VirtualRegister(currentInstruction[3].u.operand));	3534	Node* value = get(VirtualRegister(currentInstruction[3].u.operand));
3541	Node* base = get(VirtualRegister(currentInstruction[1].u.operand));	3535	Node* base = get(VirtualRegister(currentInstruction[1].u.operand));
3542	unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[currentInstruction[2].u.operand];	3536	unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[currentInstruction[2].u.operand];
3543	bool direct = currentInstruction[8].u.operand;	3537	bool direct = currentInstruction[8].u.putByIdFlags & PutByIdFalgs::IsDirect;
3544		3538
3545	PutByIdStatus putByIdStatus = PutByIdStatus::computeFor(	3539	PutByIdStatus putByIdStatus = PutByIdStatus::computeFor(
3546	m_inlineStackTop->m_profiledBlock, m_dfgCodeBlock,	3540	m_inlineStackTop->m_profiledBlock, m_dfgCodeBlock,

Lines 468-484 macro valueProfile(value, operand, scrat Source/JavaScriptCore/llint/LowLevelInterpreter64.asm_sec1
- Source/JavaScriptCore/llint/LowLevelInterpreter64.asm -116 / +63 lines
468	storeq value, ValueProfile::m_buckets[scratch]	468	storeq value, ValueProfile::m_buckets[scratch]
469	end	469	end
470		470
471	macro loadStructure(cell, structure)	471	macro structureIDToStructureWithScratch(structureID, structure, scratch)
472	end
473
474	macro loadStructureWithScratch(cell, structure, scratch)
475	loadp CodeBlock[cfr], scratch	472	loadp CodeBlock[cfr], scratch
476	loadp CodeBlock::m_vm[scratch], scratch	473	loadp CodeBlock::m_vm[scratch], scratch
477	loadp VM::heap + Heap::m_structureIDTable + StructureIDTable::m_table[scratch], scratch	474	loadp VM::heap + Heap::m_structureIDTable + StructureIDTable::m_table[scratch], scratch
478	loadi JSCell::m_structureID[cell], structure	475	loadi structureID, structure
479	loadp [scratch, structure, 8], structure	476	loadp [scratch, structure, 8], structure
480	end	477	end
481		478
		479	macro loadStructureWithScratch(cell, structure, scratch)
		480	structureIDToStructureWithScratch(JSCell::m_structureID[cell], structure, scratch)
		481	end
		482
482	macro loadStructureAndClobberFirstArg(cell, structure)	483	macro loadStructureAndClobberFirstArg(cell, structure)
483	loadi JSCell::m_structureID[cell], structure	484	loadi JSCell::m_structureID[cell], structure
484	loadp CodeBlock[cfr], cell	485	loadp CodeBlock[cfr], cell
Lines 1204-1244 macro storePropertyAtVariableOffset(prop Source/JavaScriptCore/llint/LowLevelInterpreter64.asm_sec2
1204	storeq value, (firstOutOfLineOffset - 2) * 8[objectAndStorage, propertyOffsetAsInt, 8]	1205	storeq value, (firstOutOfLineOffset - 2) * 8[objectAndStorage, propertyOffsetAsInt, 8]
1205	end	1206	end
1206		1207
1207	macro getById(getPropertyStorage)	1208	_llint_op_get_by_id:
1208	traceExecution()	1209	traceExecution()
1209	# We only do monomorphic get_by_id caching for now, and we do not modify the
1210	# opcode. We do, however, allow for the cache to change anytime if fails, since
1211	# ping-ponging is free. At best we get lucky and the get_by_id will continue
1212	# to take fast path on the new cache. At worst we take slow path, which is what
1213	# we would have been doing anyway.
1214	loadisFromInstruction(2, t0)	1210	loadisFromInstruction(2, t0)
1215	loadConstantOrVariableCell(t0, t3, .opGetByIdSlow)	1211	loadConstantOrVariableCell(t0, t3, .opGetByIdSlow)
1216	loadStructureWithScratch(t3, t2, t1)	1212	loadi JSCell::m_structureID[t3], t1
1217	loadpFromInstruction(4, t1)	1213	loadisFromInstruction(4, t2)
1218	bpneq t2, t1, .opGetByIdSlow	1214	bineq t2, t1, .opGetByIdSlow
1219	getPropertyStorage(	1215	loadisFromInstruction(5, t1)
1220	t3,	1216	loadisFromInstruction(1, t2)
1221	t0,	1217	loadPropertyAtVariableOffset(t1, t3, t0)
1222	macro (propertyStorage, scratch)	1218	storeq t0, [cfr, t2, 8]
1223	loadisFromInstruction(5, t2)	1219	valueProfile(t0, 8, t1)
1224	loadisFromInstruction(1, t1)	1220	dispatch(9)
1225	loadq [propertyStorage, t2], scratch
1226	storeq scratch, [cfr, t1, 8]
1227	valueProfile(scratch, 8, t1)
1228	dispatch(9)
1229	end)
1230
1231	.opGetByIdSlow:
1232	callSlowPath(_llint_slow_path_get_by_id)
1233	dispatch(9)
1234	end
1235
1236	_llint_op_get_by_id:
1237	getById(withInlineStorage)
1238
1239		1221
1240	_llint_op_get_by_id_out_of_line:	1222	.opGetByIdSlow:
1241	getById(withOutOfLineStorage)	1223	callSlowPath(_llint_slow_path_get_by_id)
		1224	dispatch(9)
1242		1225
1243		1226
1244	_llint_op_get_array_length:	1227	_llint_op_get_array_length:
Lines 1264-1360 _llint_op_get_array_length: Source/JavaScriptCore/llint/LowLevelInterpreter64.asm_sec3
1264	dispatch(9)	1247	dispatch(9)
1265		1248
1266		1249
1267	macro putById(getPropertyStorage)	1250	_llint_op_put_by_id:
1268	traceExecution()	1251	traceExecution()
1269	writeBarrierOnOperands(1, 3)	1252	writeBarrierOnOperands(1, 3)
1270	loadisFromInstruction(1, t3)	1253	loadisFromInstruction(1, t3)
1271	loadConstantOrVariableCell(t3, t0, .opPutByIdSlow)	1254	loadConstantOrVariableCell(t3, t0, .opPutByIdSlow)
1272	loadStructureWithScratch(t0, t2, t1)	1255	loadi JSCell::m_structureID[t0], t2
1273	loadpFromInstruction(4, t1)	1256	loadisFromInstruction(4, t1)
1274	bpneq t2, t1, .opPutByIdSlow	1257	bineq t2, t1, .opPutByIdSlow
1275	getPropertyStorage(	1258
1276	t0,	1259	# At this point, we have:
1277	t3,	1260	# t1, t2 -> current structure ID
1278	macro (propertyStorage, scratch)	1261	# t0 -> object base
1279	loadisFromInstruction(5, t1)
1280	loadisFromInstruction(3, t2)
1281	loadConstantOrVariable(t2, scratch)
1282	storeq scratch, [propertyStorage, t1]
1283	dispatch(9)
1284	end)
1285	end
1286
1287	_llint_op_put_by_id:
1288	putById(withInlineStorage)
1289		1262
1290	.opPutByIdSlow:	1263	loadisFromInstruction(6, t1)
1291	callSlowPath(_llint_slow_path_put_by_id)	1264
1292	dispatch(9)	1265	btiz t1, .opPutByIdNotTransition
1293		1266
		1267	# This is the transition case. t1 holds the new structureID. t2 holds the old structure ID.
		1268	# If we have a chain, we need to check it. t0 is the base. We may clobber t1 to use it as
		1269	# scratch.
		1270	loadpFromInstruction(7, t3)
		1271	btpz t3, .opPutByIdTransitionDirect
		1272
		1273	loadp StructureChain::m_vector[t3], t3
		1274	assert(macro (ok) btpnz t3, ok end)
		1275
		1276	structureIDToStructureWithScratch(t2, t2, t1)
		1277	loadq Structure::m_prototype[t2], t2
		1278	bqeq t2, ValueNull, .opPutByIdTransitionChainDone
		1279	.opPutByIdTransitionChainLoop:
		1280	loadStructureAndClobberFirstArg(t2, t1)
		1281	move t1, t2
		1282	bpneq t2, [t3], .opPutByIdSlot
		1283	addp 8, t3
		1284	loadq Structure::m_prototype[t2], t2
		1285	bqneq t2, ValueNull, .opPutByIdTransitionChainLoop
1294		1286
1295	_llint_op_put_by_id_out_of_line:	1287	.opPutByIdTransitionChainDone:
1296	putById(withOutOfLineStorage)	1288	# Reload the new structure, since we clobbered it above.
		1289	loadisFromInstruction(6, t1)
1297		1290
		1291	.opPutByIdTransitionDirect:
		1292	storei t1, JSCell::m_structureID[t0]
1298		1293
1299	macro putByIdTransition(additionalChecks, getPropertyStorage)	1294	.opPutByIdNotTransition:
1300	traceExecution()	1295	# The only thing live right now is t0, which holds the base.
1301	writeBarrierOnOperand(1)	1296	loadisFromInstruction(3, t1)
1302	loadisFromInstruction(1, t3)	1297	loadConstantOrVariable(t1, t2)
1303	loadpFromInstruction(4, t1)
1304	loadConstantOrVariableCell(t3, t0, .opPutByIdSlow)
1305	loadStructureWithScratch(t0, t2, t3)
1306	bpneq t2, t1, .opPutByIdSlow
1307	additionalChecks(t1, t3, t2)
1308	loadisFromInstruction(3, t2)
1309	loadisFromInstruction(5, t1)	1298	loadisFromInstruction(5, t1)
1310	getPropertyStorage(	1299	storePropertyAtVariableOffset(t1, t0, t2)
1311	t0,	1300	dispatch(9)
1312	t3,
1313	macro (propertyStorage, scratch)
1314	addp t1, propertyStorage, t3
1315	loadConstantOrVariable(t2, t1)
1316	storeq t1, [t3]
1317	loadpFromInstruction(6, t1)
1318	loadi Structure::m_blob + StructureIDBlob::u.words.word1[t1], t1
1319	storei t1, JSCell::m_structureID[t0]
1320	dispatch(9)
1321	end)
1322	end
1323
1324	macro noAdditionalChecks(oldStructure, scratch, scratch2)
1325	end
1326
1327	macro structureChainChecks(oldStructure, scratch, scratch2)
1328	const protoCell = oldStructure # Reusing the oldStructure register for the proto
1329	loadpFromInstruction(7, scratch)
1330	assert(macro (ok) btpnz scratch, ok end)
1331	loadp StructureChain::m_vector[scratch], scratch
1332	assert(macro (ok) btpnz scratch, ok end)
1333	bqeq Structure::m_prototype[oldStructure], ValueNull, .done
1334	.loop:
1335	loadq Structure::m_prototype[oldStructure], protoCell
1336	loadStructureAndClobberFirstArg(protoCell, scratch2)
1337	move scratch2, oldStructure
1338	bpneq oldStructure, [scratch], .opPutByIdSlow
1339	addp 8, scratch
1340	bqneq Structure::m_prototype[oldStructure], ValueNull, .loop
1341	.done:
1342	end
1343
1344	_llint_op_put_by_id_transition_direct:
1345	putByIdTransition(noAdditionalChecks, withInlineStorage)
1346
1347
1348	_llint_op_put_by_id_transition_direct_out_of_line:
1349	putByIdTransition(noAdditionalChecks, withOutOfLineStorage)
1350
1351
1352	_llint_op_put_by_id_transition_normal:
1353	putByIdTransition(structureChainChecks, withInlineStorage)
1354
1355		1301
1356	_llint_op_put_by_id_transition_normal_out_of_line:	1302	.opPutByIdSlow:
1357	putByIdTransition(structureChainChecks, withOutOfLineStorage)	1303	callSlowPath(_llint_slow_path_put_by_id)
		1304	dispatch(9)
1358		1305
1359		1306
1360	_llint_op_get_by_val:	1307	_llint_op_get_by_val:

Lines 105-110 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec1
- Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj +8 lines
105	0F13912B16771C3A009CCB07 /* ProfilerProfiledBytecodes.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0F13912616771C30009CCB07 / ProfilerProfiledBytecodes.cpp */; };	105	0F13912B16771C3A009CCB07 /* ProfilerProfiledBytecodes.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0F13912616771C30009CCB07 / ProfilerProfiledBytecodes.cpp */; };
106	0F13912C16771C3D009CCB07 /* ProfilerProfiledBytecodes.h in Headers / = {isa = PBXBuildFile; fileRef = 0F13912716771C30009CCB07 / ProfilerProfiledBytecodes.h */; settings = {ATTRIBUTES = (Private, ); }; };	106	0F13912C16771C3D009CCB07 /* ProfilerProfiledBytecodes.h in Headers / = {isa = PBXBuildFile; fileRef = 0F13912716771C30009CCB07 / ProfilerProfiledBytecodes.h */; settings = {ATTRIBUTES = (Private, ); }; };
107	0F13E04E16164A1F00DC8DE7 /* IndexingType.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0F13E04C16164A1B00DC8DE7 / IndexingType.cpp */; };	107	0F13E04E16164A1F00DC8DE7 /* IndexingType.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0F13E04C16164A1B00DC8DE7 / IndexingType.cpp */; };
		108	0F15CD221BA5F9860031FFD3 /* PutByIdFlags.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0F15CD201BA5F9860031FFD3 / PutByIdFlags.cpp */; };
		109	0F15CD231BA5F9860031FFD3 /* PutByIdFlags.h in Headers / = {isa = PBXBuildFile; fileRef = 0F15CD211BA5F9860031FFD3 / PutByIdFlags.h */; settings = {ATTRIBUTES = (Private, ); }; };
108	0F15F15F14B7A73E005DE37D /* CommonSlowPaths.h in Headers / = {isa = PBXBuildFile; fileRef = 0F15F15D14B7A73A005DE37D / CommonSlowPaths.h */; settings = {ATTRIBUTES = (Private, ); }; };	110	0F15F15F14B7A73E005DE37D /* CommonSlowPaths.h in Headers / = {isa = PBXBuildFile; fileRef = 0F15F15D14B7A73A005DE37D / CommonSlowPaths.h */; settings = {ATTRIBUTES = (Private, ); }; };
109	0F1725FF1B48719A00AC3A55 /* DFGMinifiedGraph.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0F1725FE1B48719A00AC3A55 / DFGMinifiedGraph.cpp */; };	111	0F1725FF1B48719A00AC3A55 /* DFGMinifiedGraph.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0F1725FE1B48719A00AC3A55 / DFGMinifiedGraph.cpp */; };
110	0F18D3CF1B55A6E0002C5C9F /* DFGAdaptiveStructureWatchpoint.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0F18D3CD1B55A6E0002C5C9F / DFGAdaptiveStructureWatchpoint.cpp */; };	112	0F18D3CF1B55A6E0002C5C9F /* DFGAdaptiveStructureWatchpoint.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0F18D3CD1B55A6E0002C5C9F / DFGAdaptiveStructureWatchpoint.cpp */; };
Lines 1932-1937 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec2
1932	0F13912616771C30009CCB07 /* ProfilerProfiledBytecodes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ProfilerProfiledBytecodes.cpp; path = profiler/ProfilerProfiledBytecodes.cpp; sourceTree = "<group>"; };	1934	0F13912616771C30009CCB07 /* ProfilerProfiledBytecodes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ProfilerProfiledBytecodes.cpp; path = profiler/ProfilerProfiledBytecodes.cpp; sourceTree = "<group>"; };
1933	0F13912716771C30009CCB07 /* ProfilerProfiledBytecodes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ProfilerProfiledBytecodes.h; path = profiler/ProfilerProfiledBytecodes.h; sourceTree = "<group>"; };	1935	0F13912716771C30009CCB07 /* ProfilerProfiledBytecodes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ProfilerProfiledBytecodes.h; path = profiler/ProfilerProfiledBytecodes.h; sourceTree = "<group>"; };
1934	0F13E04C16164A1B00DC8DE7 /* IndexingType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IndexingType.cpp; sourceTree = "<group>"; };	1936	0F13E04C16164A1B00DC8DE7 /* IndexingType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IndexingType.cpp; sourceTree = "<group>"; };
		1937	0F15CD201BA5F9860031FFD3 /* PutByIdFlags.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PutByIdFlags.cpp; sourceTree = "<group>"; };
		1938	0F15CD211BA5F9860031FFD3 /* PutByIdFlags.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PutByIdFlags.h; sourceTree = "<group>"; };
1935	0F15F15D14B7A73A005DE37D /* CommonSlowPaths.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CommonSlowPaths.h; sourceTree = "<group>"; };	1939	0F15F15D14B7A73A005DE37D /* CommonSlowPaths.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CommonSlowPaths.h; sourceTree = "<group>"; };
1936	0F1725FE1B48719A00AC3A55 /* DFGMinifiedGraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DFGMinifiedGraph.cpp; path = dfg/DFGMinifiedGraph.cpp; sourceTree = "<group>"; };	1940	0F1725FE1B48719A00AC3A55 /* DFGMinifiedGraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DFGMinifiedGraph.cpp; path = dfg/DFGMinifiedGraph.cpp; sourceTree = "<group>"; };
1937	0F18D3CD1B55A6E0002C5C9F /* DFGAdaptiveStructureWatchpoint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DFGAdaptiveStructureWatchpoint.cpp; path = dfg/DFGAdaptiveStructureWatchpoint.cpp; sourceTree = "<group>"; };	1941	0F18D3CD1B55A6E0002C5C9F /* DFGAdaptiveStructureWatchpoint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DFGAdaptiveStructureWatchpoint.cpp; path = dfg/DFGAdaptiveStructureWatchpoint.cpp; sourceTree = "<group>"; };
Lines 5600-5605 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec3
5600	0F98205E16BFE37F00240D02 /* PreciseJumpTargets.h */,	5604	0F98205E16BFE37F00240D02 /* PreciseJumpTargets.h */,
5601	0FD3E4071B618B6600C80E1E /* PropertyCondition.cpp */,	5605	0FD3E4071B618B6600C80E1E /* PropertyCondition.cpp */,
5602	0FD3E4081B618B6600C80E1E /* PropertyCondition.h */,	5606	0FD3E4081B618B6600C80E1E /* PropertyCondition.h */,
		5607	0F15CD201BA5F9860031FFD3 /* PutByIdFlags.cpp */,
		5608	0F15CD211BA5F9860031FFD3 /* PutByIdFlags.h */,
5603	0F93329914CA7DC10085F3C6 /* PutByIdStatus.cpp */,	5609	0F93329914CA7DC10085F3C6 /* PutByIdStatus.cpp */,
5604	0F93329A14CA7DC10085F3C6 /* PutByIdStatus.h */,	5610	0F93329A14CA7DC10085F3C6 /* PutByIdStatus.h */,
5605	0F93B4A718B92C4D00178A3F /* PutByIdVariant.cpp */,	5611	0F93B4A718B92C4D00178A3F /* PutByIdVariant.cpp */,
Lines 6740-6745 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec4
6740	0F682FB319BCB36400FA3BAD /* DFGSSACalculator.h in Headers */,	6746	0F682FB319BCB36400FA3BAD /* DFGSSACalculator.h in Headers */,
6741	0FB7F39D15ED8E4600F167B2 /* Reject.h in Headers */,	6747	0FB7F39D15ED8E4600F167B2 /* Reject.h in Headers */,
6742	0F2D4DEA19832DAC007D4B19 /* TypeLocation.h in Headers */,	6748	0F2D4DEA19832DAC007D4B19 /* TypeLocation.h in Headers */,
		6749	0F15CD231BA5F9860031FFD3 /* PutByIdFlags.h in Headers */,
6743	A5BA15E8182340B300A82E69 /* RemoteInspector.h in Headers */,	6750	A5BA15E8182340B300A82E69 /* RemoteInspector.h in Headers */,
6744	A5BA15EA182340B400A82E69 /* RemoteInspectorConstants.h in Headers */,	6751	A5BA15EA182340B400A82E69 /* RemoteInspectorConstants.h in Headers */,
6745	A5BA15F0182345AF00A82E69 /* RemoteInspectorDebuggable.h in Headers */,	6752	A5BA15F0182345AF00A82E69 /* RemoteInspectorDebuggable.h in Headers */,
Lines 7472-7477 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec5
7472	0FFFC95914EF90A600C72532 /* DFGCSEPhase.cpp in Sources */,	7479	0FFFC95914EF90A600C72532 /* DFGCSEPhase.cpp in Sources */,
7473	0F2FC77216E12F710038D976 /* DFGDCEPhase.cpp in Sources */,	7480	0F2FC77216E12F710038D976 /* DFGDCEPhase.cpp in Sources */,
7474	0F8F2B99172F04FF007DBDA5 /* DFGDesiredIdentifiers.cpp in Sources */,	7481	0F8F2B99172F04FF007DBDA5 /* DFGDesiredIdentifiers.cpp in Sources */,
		7482	0F15CD221BA5F9860031FFD3 /* PutByIdFlags.cpp in Sources */,
7475	C2C0F7CD17BBFC5B00464FE4 /* DFGDesiredTransitions.cpp in Sources */,	7483	C2C0F7CD17BBFC5B00464FE4 /* DFGDesiredTransitions.cpp in Sources */,
7476	0FE8534B1723CDA500B618F5 /* DFGDesiredWatchpoints.cpp in Sources */,	7484	0FE8534B1723CDA500B618F5 /* DFGDesiredWatchpoints.cpp in Sources */,
7477	C2981FD817BAEE4B00A3BC98 /* DFGDesiredWeakReferences.cpp in Sources */,	7485	C2981FD817BAEE4B00A3BC98 /* DFGDesiredWeakReferences.cpp in Sources */,

Lines 57-70 Source/JavaScriptCore/bytecode/BytecodeList.json_sec1
- Source/JavaScriptCore/bytecode/BytecodeList.json -6 lines
57	{ "name" : "op_is_function", "length" : 3 },	57	{ "name" : "op_is_function", "length" : 3 },
58	{ "name" : "op_in", "length" : 4 },	58	{ "name" : "op_in", "length" : 4 },
59	{ "name" : "op_get_by_id", "length" : 9 },	59	{ "name" : "op_get_by_id", "length" : 9 },
60	{ "name" : "op_get_by_id_out_of_line", "length" : 9 },
61	{ "name" : "op_get_array_length", "length" : 9 },	60	{ "name" : "op_get_array_length", "length" : 9 },
62	{ "name" : "op_put_by_id", "length" : 9 },	61	{ "name" : "op_put_by_id", "length" : 9 },
63	{ "name" : "op_put_by_id_out_of_line", "length" : 9 },
64	{ "name" : "op_put_by_id_transition_direct", "length" : 9 },
65	{ "name" : "op_put_by_id_transition_direct_out_of_line", "length" : 9 },
66	{ "name" : "op_put_by_id_transition_normal", "length" : 9 },
67	{ "name" : "op_put_by_id_transition_normal_out_of_line", "length" : 9 },
68	{ "name" : "op_del_by_id", "length" : 4 },	62	{ "name" : "op_del_by_id", "length" : 4 },
69	{ "name" : "op_get_by_val", "length" : 6 },	63	{ "name" : "op_get_by_val", "length" : 6 },
70	{ "name" : "op_put_by_val", "length" : 5 },	64	{ "name" : "op_put_by_val", "length" : 5 },

Line 0 Source/JavaScriptCore/bytecode/PutByIdFlags.cpp_sec1
- Source/JavaScriptCore/bytecode/PutByIdFlags.cpp +51 lines
	1	/*
	2	* Copyright (C) 2015 Apple Inc. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (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.
	24	*/
	25
	26	#include "config.h"
	27	#include "PutByIdFlags.h"
	28
	29	#include <wtf/CommaPrinter.h>
	30	#include <wtf/PrintStream.h>
	31	#include <wtf/StringPrintStream.h>
	32
	33	namespace WTF {
	34
	35	using namespace JSC;
	36
	37	void printInternal(PrintStream& out, PutByIdFlags flags) {
	38	StringPrintStream stringOut;
	39	CommaPrinter comma("\|");
	40	if (flags & IsDirect)
	41	stringOut.print(comma, "IsDirect");
	42
	43	CString string = stringOut.toCString();
	44	if (!string.length())
	45	out.print("None");
	46	else
	47	out.print(string);
	48	}
	49
	50	} // namespace WTF
	51

Lines 36-41 Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h_sec1
- Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h +3 lines
36	#include "JSCell.h"	36	#include "JSCell.h"
37	#include "JSString.h"	37	#include "JSString.h"
38	#include "ParserModes.h"	38	#include "ParserModes.h"
		39	#include "PutByIdFlags.h"
39	#include "RegExp.h"	40	#include "RegExp.h"
40	#include "SpecialPointer.h"	41	#include "SpecialPointer.h"
41	#include "UnlinkedFunctionExecutable.h"	42	#include "UnlinkedFunctionExecutable.h"
Lines 97-106 struct UnlinkedInstruction { Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h_sec2
97	UnlinkedInstruction() { u.operand = 0; }	98	UnlinkedInstruction() { u.operand = 0; }
98	UnlinkedInstruction(OpcodeID opcode) { u.opcode = opcode; }	99	UnlinkedInstruction(OpcodeID opcode) { u.opcode = opcode; }
99	UnlinkedInstruction(int operand) { u.operand = operand; }	100	UnlinkedInstruction(int operand) { u.operand = operand; }
		101	UnlinkedInstruction(PutByIdFlags flags) { u.putByIdFlags = flags; }
100	union {	102	union {
101	OpcodeID opcode;	103	OpcodeID opcode;
102	int32_t operand;	104	int32_t operand;
103	unsigned index;	105	unsigned index;
		106	PutByIdFlags putByIdFlags;
104	} u;	107	} u;
105	};	108	};
106		109

Lines 152-165 CapabilityLevel capabilityLevel(OpcodeID Source/JavaScriptCore/dfg/DFGCapabilities.cpp_sec1
- Source/JavaScriptCore/dfg/DFGCapabilities.cpp -6 lines
152	case op_put_by_val:	152	case op_put_by_val:
153	case op_put_by_val_direct:	153	case op_put_by_val_direct:
154	case op_get_by_id:	154	case op_get_by_id:
155	case op_get_by_id_out_of_line:
156	case op_get_array_length:	155	case op_get_array_length:
157	case op_put_by_id:	156	case op_put_by_id:
158	case op_put_by_id_out_of_line:
159	case op_put_by_id_transition_direct:
160	case op_put_by_id_transition_direct_out_of_line:
161	case op_put_by_id_transition_normal:
162	case op_put_by_id_transition_normal_out_of_line:
163	case op_jmp:	157	case op_jmp:
164	case op_jtrue:	158	case op_jtrue:
165	case op_jfalse:	159	case op_jfalse:

Lines 217-223 void JIT::privateCompileMainPass() Source/JavaScriptCore/jit/JIT.cpp_sec1
- Source/JavaScriptCore/jit/JIT.cpp -6 lines
217	DEFINE_OP(op_load_arrowfunction_this)	217	DEFINE_OP(op_load_arrowfunction_this)
218	DEFINE_OP(op_eq)	218	DEFINE_OP(op_eq)
219	DEFINE_OP(op_eq_null)	219	DEFINE_OP(op_eq_null)
220	case op_get_by_id_out_of_line:
221	case op_get_array_length:	220	case op_get_array_length:
222	DEFINE_OP(op_get_by_id)	221	DEFINE_OP(op_get_by_id)
223	DEFINE_OP(op_get_by_val)	222	DEFINE_OP(op_get_by_val)
Lines 269-279 void JIT::privateCompileMainPass() Source/JavaScriptCore/jit/JIT.cpp_sec2
269	DEFINE_OP(op_push_with_scope)	268	DEFINE_OP(op_push_with_scope)
270	DEFINE_OP(op_create_lexical_environment)	269	DEFINE_OP(op_create_lexical_environment)
271	DEFINE_OP(op_get_parent_scope)	270	DEFINE_OP(op_get_parent_scope)
272	case op_put_by_id_out_of_line:
273	case op_put_by_id_transition_direct:
274	case op_put_by_id_transition_normal:
275	case op_put_by_id_transition_direct_out_of_line:
276	case op_put_by_id_transition_normal_out_of_line:
277	DEFINE_OP(op_put_by_id)	271	DEFINE_OP(op_put_by_id)
278	DEFINE_OP(op_put_by_index)	272	DEFINE_OP(op_put_by_index)
279	case op_put_by_val_direct:	273	case op_put_by_val_direct: