Attachment #283113 for bug #151141

View Details Raw Unified Return to Bug 151141

| Differences between

and this patch



2016-05-29  Filip Pizlo  <fpizlo@apple.com>

        Implement table-based switches in B3/Air
        https://bugs.webkit.org/show_bug.cgi?id=151141

        Reviewed by NOBODY (OOPS!).
        
        If a switch statement gets large, it's better to express it as an indirect jump rather than
        using a binary switch (divide-and-conquer tree of comparisons leading to O(log n) branches to
        get to the switch case). When dealing with integer switches, FTL will already use the B3
        Switch and expect this to get lowered as efficiently as possible; it's a bug that B3 will
        always use a binary switch rather than indirect jumps. When dealing with switches over some
        more sophisticated types, we'd want FTL to build an indirect jump table itself and use
        something like a hashtable to feed it. In that case, there will be no B3 Switch; we'll want
        some kind of indirect jump instruction.
        
        This implies that we want B3 to have the ability to lower Switch to indirect jumps and to
        expose those indirect jumps in IR so that the FTL could do its own indirect jumps for
        switches over more complicated things like strings. This change introduces an indirect jump
        instruction to B3 and calls it PolyJump. It has some unique semantics that make it very
        different from "indirect jumps", "indirect branches", and "computed gotos" - all terms of art
        used in other compilers.
        
        This implements the most basic kind of Switch-to-PolyJump lowering in B3::lowerMacros(). As
        part of the existing divide-and-conquer that creates branches, if it detects that the set of
        cases satisfies some conditions (density of case values and total size), then it will emit a
        PolyJump.
        
        The problem with classic indirect jumps is that they force the compiler to be conservative
        about control flow. The compiler must assume that the indirect jump may transfer control flow
        to any escaped block (block labeled as being a possible target for indirect jumps, or if no
        such labeling is available, the compiler must assume that it may target any block). The worst
        part is that the implicit control flow edges from the indirect jump to the escaped blocks
        cannot be broken. This invalidates a principle of B3 IR: any phase may break any critical
        edge for any reason. Our SSA conversion would break if we revoked this feature. It's actually
        much worse than this - basically any logic over control flow would have to be hacked to deal
        with these unbreakable edges. This would mean changing all CFG transformation utilities and
        passes. We have a lot of those and we want it to be easy to write new ones.
        
        This is why we use something new and quite different from classic indirect jumps. PolyJump
        makes the control flow edges explicit. The client must supply the successors when it creates
        the PolyJump. The compiler may rewire those successor edges the same way that it would rewire
        any control flow edges. Consequently the vast majority of CFG reasoning in B3 is unchanged.
        If you don't want to understand PolyJump, just think of it like you would a Switch with an
        opaque incoming value. This works because we do not add any notion of escaped basic blocks.
        Instead of letting the client get the pointers to basic blocks by escaping them like in LLVM,
        you can only get the pointers of the successors of PolyJump by registering a callback with
        PolyJump. This callback doesn't actually give you the addresses of basic blocks. It just
        gives you the addresses where you must jump to transfer control flow from that PolyJump to
        its successors. This means that the magic of PolyJump is confined only to the PolyJump itself
        and doesn't infect reasoning about the basic blocks that it jumps to.
        
        The only downside is that that PolyJump is not cloneable. You can't clone it because if you
        did, then the two resulting PolyJumps may have their successor edges rewired independently of
        each other. This could easily happen if we break critical edges. If that did happen then it
        would break the client of PolyJump: they would have already created something like a jump
        table and will be populating it via the callback, but now the callback will be called twice,
        and may return different jump destinations each time. So, this patch introduces
        Value::isCloneable() and teaches both of our code specialization optimizations (tail
        duplication and select specialization) to bail if the code they want to specialize is not
        cloneable. This is totally benign most of the time, since those optimizations usually run
        before Switch lowering. Clients that use PolyJump directly have to appreciate the trade-off:
        PolyJump may gain them some performance but they are opting out of optimizations that use
        cloning. A close corollary of the no-clone rule is that the client cannot create multiple
        PolyJumps that are fed by a common jump table: the fact that each PolyJump has a callback
        that just tells you the jump destinations for its successor *edges*, not successor *blocks*,
        means that if you create two PolyJumps and give them the same successor list, you are not
        guaranteed that they will get the same jump destinations. This hurts if you want to use
        PolyJump for threaded interpreters but it's harmless for switch lowering. The goal of
        PolyJump is to be awesome for switch lowering while not breaking the rest of the compiler, so
        this is probably fine.
        
        The isCloneable() method currently only returns true for PolyJump, but I anticipate we will
        add other non-cloneable things later. I think is is inherent in a compiler that allows such
        customizeability for its clients. For example, we may want to add a flag to Patchpoint that
        makes it non-cloneable. Sometimes we have to jump through hoops in the FTL because of the
        cloneability of patchpoints. This happens in OSR exits, which pay a significant memory cost
        for additional data structures that are there in case an exit gets cloned. It may be more
        profitable to just say that OSR exits (i.e. Checks and InvalidationPoint Patchpoints) are not
        cloneable. Surely this would reduce tail duplication, but tail duplication is most profitable
        when it clones only a tiny amount of code; if there's an exit then we're not talking about a
        tiny amount of code anymore.
        
        This is a ~30% speed-up on microbenchmarks that have big switch statements (~60 cases). It's
        not a speed-up on mainstream benchmarks.
        
        This also adds a new test to testb3 for PolyJump, Get, and Set. The FTL does not currently
        use PolyJump directly, but we want this to be possible. It also doesn't use Get/Set directly
        even though we want this to be possible. It's important to test these since opcodes that
        result from lowering don't affect early phases, so we could have regressions in early phases
        related to these opcodes that wouldn't be caught by any JS test. So, this adds a very basic
        threaded interpreter to testb3 for a Brainfuck-style language, and tests it by having it run
        a program that prints the numbers 1..100 in a loop. Unlike a real threaded interpreter, it
        uses a common dispatch block rather than having dispatch at the terminus of each opcode.
        That's necessary because PolyJump is not cloneable. The state of the interpreter is
        represented using Variables that we Get and Set, so it tests Get/Set as well.

        * CMakeLists.txt:
        * JavaScriptCore.xcodeproj/project.pbxproj:
        * assembler/MacroAssemblerX86Common.h:
        (JSC::MacroAssemblerX86Common::jump):
        * assembler/X86Assembler.h:
        (JSC::X86Assembler::jmp_m):
        * b3/B3BasicBlock.cpp:
        (JSC::B3::BasicBlock::updatePredecessorsAfter):
        (JSC::B3::BasicBlock::isCloneable):
        (JSC::B3::BasicBlock::dump):
        * b3/B3BasicBlock.h:
        (JSC::B3::BasicBlock::frequency):
        * b3/B3Common.h:
        (JSC::B3::is64Bit):
        * b3/B3ControlValue.h:
        * b3/B3DataSection.cpp:
        (JSC::B3::DataSection::DataSection):
        * b3/B3DuplicateTails.cpp:
        * b3/B3LowerMacros.cpp:
        * b3/B3LowerToAir.cpp:
        (JSC::B3::Air::LowerToAir::lower):
        * b3/B3Opcode.cpp:
        (WTF::printInternal):
        * b3/B3Opcode.h:
        * b3/B3PolyJumpValue.cpp: Added.
        (JSC::B3::PolyJumpValue::~PolyJumpValue):
        (JSC::B3::PolyJumpValue::appendSuccessor):
        (JSC::B3::PolyJumpValue::setCallbackTask):
        (JSC::B3::PolyJumpValue::isCloneable):
        (JSC::B3::PolyJumpValue::dumpMeta):
        (JSC::B3::PolyJumpValue::cloneImpl):
        (JSC::B3::PolyJumpValue::PolyJumpValue):
        * b3/B3PolyJumpValue.h: Added.
        (JSC::B3::PolyJumpValue::accepts):
        (JSC::B3::PolyJumpValue::setCallback):
        (JSC::B3::PolyJumpValue::callbackTask):
        * b3/B3Procedure.cpp:
        (JSC::B3::Procedure::clone):
        * b3/B3Procedure.h:
        (JSC::B3::Procedure::lastPhaseName):
        (JSC::B3::Procedure::byproducts):
        * b3/B3ReduceStrength.cpp:
        * b3/B3Validate.cpp:
        * b3/B3Value.cpp:
        (JSC::B3::Value::effects):
        (JSC::B3::Value::isCloneable):
        (JSC::B3::Value::key):
        * b3/B3Value.h:
        * b3/air/AirCode.h:
        * b3/air/AirGenerate.cpp:
        (JSC::B3::Air::generate):
        * b3/air/AirInst.cpp:
        (JSC::B3::Air::Inst::hasArgEffects):
        (JSC::B3::Air::Inst::isCloneable):
        (JSC::B3::Air::Inst::dump):
        * b3/air/AirInst.h:
        * b3/air/AirOpcode.opcodes:
        * b3/testb3.cpp:
        (JSC::B3::shouldBeVerbose):
        (JSC::B3::testSwitchChillDiv):
        (JSC::B3::testLateRegister):
        (JSC::B3::threadedInterpreterPrint):
        (JSC::B3::testThreadedInterpreter):
        (JSC::B3::zero):
        (JSC::B3::run):

2016-07-03  Per Arne Vollan  <pvollan@apple.com>

        [Win] DLLs are missing version information.



    b3/B3BlockInsertionSet.cpp
    b3/B3BreakCriticalEdges.cpp
    b3/B3CCallValue.cpp
    b3/B3CaseCollection.cpp
    b3/B3CheckSpecial.cpp
    b3/B3CheckValue.cpp
    b3/B3Common.cpp

    b3/B3ConstDoubleValue.cpp
    b3/B3ConstFloatValue.cpp
    b3/B3ConstrainedValue.cpp
    b3/B3ControlValue.cpp
    b3/B3DataSection.cpp
    b3/B3DuplicateTails.cpp
    b3/B3Effects.cpp

Lines 2874-2879 public: Source/JavaScriptCore/assembler/MacroAssemblerARM64.h_sec1
- Source/JavaScriptCore/assembler/MacroAssemblerARM64.h +6 lines
2874	load64(address, getCachedDataTempRegisterIDAndInvalidate());	2874	load64(address, getCachedDataTempRegisterIDAndInvalidate());
2875	m_assembler.br(dataTempRegister);	2875	m_assembler.br(dataTempRegister);
2876	}	2876	}
		2877
		2878	void jump(BaseIndex address)
		2879	{
		2880	load64(address, getCachedDataTempRegisterIDAndInvalidate());
		2881	m_assembler.br(dataTempRegister);
		2882	}
2877		2883
2878	void jump(AbsoluteAddress address)	2884	void jump(AbsoluteAddress address)
2879	{	2885	{

Lines 2263-2268 public: Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h_sec1
- Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h +6 lines
2263	m_assembler.jmp_m(address.offset, address.base);	2263	m_assembler.jmp_m(address.offset, address.base);
2264	}	2264	}
2265		2265
		2266	// Address is a memory location containing the address to jump to
		2267	void jump(BaseIndex address)
		2268	{
		2269	m_assembler.jmp_m(address.offset, address.base, address.index, address.scale);
		2270	}
		2271
2266		2272
2267	// Arithmetic control flow operations:	2273	// Arithmetic control flow operations:
2268	//	2274	//

Lines 1983-1988 public: Source/JavaScriptCore/assembler/X86Assembler.h_sec1
- Source/JavaScriptCore/assembler/X86Assembler.h +5 lines
1983	m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, base, offset);	1983	m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, base, offset);
1984	}	1984	}
1985		1985
		1986	void jmp_m(int offset, RegisterID base, RegisterID index, int scale)
		1987	{
		1988	m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, base, index, scale, offset);
		1989	}
		1990
1986	#if !CPU(X86_64)	1991	#if !CPU(X86_64)
1987	void jmp_m(const void* address)	1992	void jmp_m(const void* address)
1988	{	1993	{




#include "B3BasicBlockInlines.h"
#include "B3BasicBlockUtils.h"
#include "B3ControlValue.h"
#include "B3Procedure.h"
#include "B3ValueInlines.h"
#include <wtf/ListDump.h>

void BasicBlock::append(Value* value)
{
    m_values.append(value);
    value->owner = this;
}

void BasicBlock::appendNonTerminal(Value* value)
{
    m_values.append(m_values.last());
    m_values[m_values.size() - 1] = value;
    value->owner = this;
}

void BasicBlock::removeLast(Procedure& proc)

    return appendIntConstant(proc, likeValue->origin(), likeValue->type(), value);
}

void BasicBlock::clearSuccessors()
{
    m_successors.clear();
}

void BasicBlock::appendSuccessor(const FrequentedBlock& target)
{
    m_successors.append(target);
}

void BasicBlock::setSuccessors(const FrequentedBlock& target)
{
    m_successors.resize(1);
    m_successors[0] = target;
}

void BasicBlock::setSuccessors(const FrequentedBlock& taken, const FrequentedBlock& notTaken)
{
    m_successors.resize(2);
    m_successors[0] = taken;
    m_successors[1] = notTaken;
}

bool BasicBlock::replaceSuccessor(BasicBlock* from, BasicBlock* to)
{
    bool result = false;
    for (BasicBlock*& successor : successorBlocks()) {
        if (successor == from) {
            successor = to;
            result = true;
            
            // Keep looping because a successor may be mentioned multiple times, like in a Switch.
        }
    }
    return result;
}

bool BasicBlock::addPredecessor(BasicBlock* block)

        out.print("  Predecessors: ", pointerListDump(predecessors()), "\n");
    for (Value* value : *this)
        out.print("    ", B3::deepDump(proc, value), "\n");
    if (successors().size()) {
        out.print("  Successors: ");
        if (size())
            last()->dumpSuccessors(this, out);
        else
            out.print(listDump(successors()));
        out.print("\n");
    }
}

Value* BasicBlock::appendNewControlValue(Procedure& proc, Opcode opcode, Origin origin)
{
    RELEASE_ASSERT(opcode == Oops);
    clearSuccessors();
    return appendNew<Value>(proc, opcode, origin);
}

Value* BasicBlock::appendNewControlValue(Procedure& proc, Opcode opcode, Origin origin, Value* value)
{
    RELEASE_ASSERT(opcode == Return);
    clearSuccessors();
    return appendNew<Value>(proc, opcode, origin, value);
}

Value* BasicBlock::appendNewControlValue(Procedure& proc, Opcode opcode, Origin origin, const FrequentedBlock& target)
{
    RELEASE_ASSERT(opcode == Jump);
    setSuccessors(target);
    return appendNew<Value>(proc, opcode, origin);
}

Value* BasicBlock::appendNewControlValue(Procedure& proc, Opcode opcode, Origin origin, Value* predicate, const FrequentedBlock& taken, const FrequentedBlock& notTaken)
{
    RELEASE_ASSERT(opcode == Branch);
    setSuccessors(taken, notTaken);
    return appendNew<Value>(proc, opcode, origin, predicate);
}

} } // namespace JSC::B3



#if ENABLE(B3_JIT)

#include "B3FrequentedBlock.h"
#include "B3Opcode.h"
#include "B3Origin.h"
#include "B3SuccessorCollection.h"
#include "B3Type.h"

public:
    typedef Vector<Value*> ValueList;
    typedef Vector<BasicBlock*, 2> PredecessorList;
    typedef Vector<FrequentedBlock, 2> SuccessorList;

    static const char* const dumpPrefix;


    ValueType* appendNew(Procedure&, Arguments...);
    template<typename ValueType, typename... Arguments>
    ValueType* appendNewNonTerminal(Procedure&, Arguments...);
    
    JS_EXPORT_PRIVATE Value* appendIntConstant(Procedure&, Origin, Type, int64_t value);
    Value* appendIntConstant(Procedure&, Value* likeValue, int64_t value);


    template<typename ValueType, typename... Arguments>
    ValueType* replaceLastWithNew(Procedure&, Arguments...);

    unsigned numSuccessors() const { return m_successors.size(); }
    const FrequentedBlock& successor(unsigned index) const { return m_successors[index]; }
    FrequentedBlock& successor(unsigned index) { return m_successors[index]; }
    const SuccessorList& successors() const { return m_successors; }
    SuccessorList& successors() { return m_successors; }
    
    void clearSuccessors();
    JS_EXPORT_PRIVATE void appendSuccessor(const FrequentedBlock&);
    void setSuccessors(const FrequentedBlock&);
    void setSuccessors(const FrequentedBlock&, const FrequentedBlock&);

    BasicBlock* successorBlock(unsigned index) const { return successor(index).block(); }
    BasicBlock*& successorBlock(unsigned index) { return successor(index).block(); }
    SuccessorCollection<BasicBlock, SuccessorList> successorBlocks()
    {
        return SuccessorCollection<BasicBlock, SuccessorList>(successors());
    }
    SuccessorCollection<const BasicBlock, const SuccessorList> successorBlocks() const
    {
        return SuccessorCollection<const BasicBlock, const SuccessorList>(successors());
    }

    bool replaceSuccessor(BasicBlock* from, BasicBlock* to);
    
    // This is only valid for Jump and Branch.
    const FrequentedBlock& taken() const;
    FrequentedBlock& taken();
    // This is only valid for Branch.
    const FrequentedBlock& notTaken() const;
    FrequentedBlock& notTaken();
    // This is only valid for Branch and Switch.
    const FrequentedBlock& fallThrough() const;
    FrequentedBlock& fallThrough();

    unsigned numPredecessors() const { return m_predecessors.size(); }
    BasicBlock* predecessor(unsigned index) const { return m_predecessors[index]; }

    void updatePredecessorsAfter();

    double frequency() const { return m_frequency; }
    
    void dump(PrintStream&) const;
    void deepDump(const Procedure&, PrintStream&) const;

    // These are deprecated method for compatibility with the old ControlValue class. Don't use them
    // in new code.
    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=159440
    
    // Use this for Oops.
    JS_EXPORT_PRIVATE Value* appendNewControlValue(Procedure&, Opcode, Origin);
    // Use this for Return.
    JS_EXPORT_PRIVATE Value* appendNewControlValue(Procedure&, Opcode, Origin, Value*);
    // Use this for Jump.
    JS_EXPORT_PRIVATE Value* appendNewControlValue(Procedure&, Opcode, Origin, const FrequentedBlock&);
    // Use this for Branch.
    JS_EXPORT_PRIVATE Value* appendNewControlValue(Procedure&, Opcode, Origin, Value*, const FrequentedBlock&, const FrequentedBlock&);
    
private:
    friend class BlockInsertionSet;
    friend class InsertionSet;

    unsigned m_index;
    ValueList m_values;
    PredecessorList m_predecessors;
    SuccessorList m_successors;
    double m_frequency;
};




#if ENABLE(B3_JIT)

#include "B3BasicBlock.h"
#include "B3ControlValue.h"
#include "B3ProcedureInlines.h"
#include "B3Value.h"

namespace JSC { namespace B3 {


    return result;
}

inline const FrequentedBlock& BasicBlock::taken() const
{
    ASSERT(last()->opcode() == Jump || last()->opcode() == Branch);
    return m_successors[0];
}

inline FrequentedBlock& BasicBlock::taken()
{
    ASSERT(last()->opcode() == Jump || last()->opcode() == Branch);
    return m_successors[0];
}

inline const FrequentedBlock& BasicBlock::notTaken() const
{
    ASSERT(last()->opcode() == Branch);
    return m_successors[1];
}

inline FrequentedBlock& BasicBlock::notTaken()
{
    ASSERT(last()->opcode() == Branch);
    return m_successors[1];
}

inline const FrequentedBlock& BasicBlock::fallThrough() const
{
    ASSERT(last()->opcode() == Branch || last()->opcode() == Switch);
    return m_successors.last();
}

inline FrequentedBlock& BasicBlock::fallThrough()
{
    ASSERT(last()->opcode() == Branch || last()->opcode() == Switch);
    return m_successors.last();

inline BasicBlock*& BasicBlock::successorBlock(unsigned index)
{
    return successor(index).block();
}

inline SuccessorCollection<BasicBlock, BasicBlock::SuccessorList> BasicBlock::successorBlocks()
{
    return SuccessorCollection<BasicBlock, SuccessorList>(successors());
}

inline SuccessorCollection<const BasicBlock, const BasicBlock::SuccessorList> BasicBlock::successorBlocks() const
{
    return SuccessorCollection<const BasicBlock, const SuccessorList>(successors());
}

} } // namespace JSC::B3



        result->m_values[i] = block->m_values[i];

    // Make the new block jump to 'block'.
    result->m_values[valueIndex] = m_proc.add<Value>(Jump, value->origin());
    result->setSuccessors(FrequentedBlock(block));

    // If we had inserted things into 'block' before this, execute those insertions now.
    if (insertionSet)




#include "B3BasicBlockInlines.h"
#include "B3BlockInsertionSet.h"
#include "B3ControlValue.h"
#include "B3ProcedureInlines.h"
#include "B3ValueInlines.h"



            BasicBlock* pad =
                insertionSet.insertBefore(successor, successor->frequency());
            pad->appendNew<Value>(proc, Jump, successor->at(0)->origin());
            pad->setSuccessors(FrequentedBlock(successor));
            pad->addPredecessor(block);
            successor->replacePredecessor(block, pad);
            successor = pad;



/*
 * Copyright (C) 2016 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 "B3CaseCollection.h"

#if ENABLE(B3_JIT)

#include "B3BasicBlockInlines.h"
#include "B3CaseCollectionInlines.h"
#include <wtf/CommaPrinter.h>

namespace JSC { namespace B3 {

void CaseCollection::dump(PrintStream& out) const
{
    CommaPrinter comma;
    for (SwitchCase switchCase : *this)
        out.print(comma, switchCase);
    out.print(comma, "default->", fallThrough());
}

} } // namespace JSC::B3

#endif // ENABLE(B3_JIT)




/*
 * Copyright (C) 2016 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 B3CaseCollection_h
#define B3CaseCollection_h

#if ENABLE(B3_JIT)

#include "B3SwitchCase.h"

namespace JSC { namespace B3 {

class BasicBlock;
class SwitchValue;

// NOTE: You'll always want to include B3CaseCollectionInlines.h when you use this.

class CaseCollection {
public:
    CaseCollection()
    {
    }
    
    CaseCollection(const SwitchValue* terminal, const BasicBlock* owner)
        : m_switch(terminal)
        , m_owner(owner)
    {
    }
    
    const FrequentedBlock& fallThrough() const;

    unsigned size() const;
    SwitchCase at(unsigned index) const;
    
    SwitchCase operator[](unsigned index) const
    {
        return at(index);
    }

    class iterator {
    public:
        iterator()
            : m_collection(nullptr)
            , m_index(0)
        {
        }

        iterator(const CaseCollection& collection, unsigned index)
            : m_collection(&collection)
            , m_index(index)
        {
        }

        SwitchCase operator*()
        {
            return m_collection->at(m_index);
        }

        iterator& operator++()
        {
            m_index++;
            return *this;
        }

        bool operator==(const iterator& other) const
        {
            ASSERT(m_collection == other.m_collection);
            return m_index == other.m_index;
        }

        bool operator!=(const iterator& other) const
        {
            return !(*this == other);
        }

    private:
        const CaseCollection* m_collection;
        unsigned m_index;
    };

    typedef iterator const_iterator;

    iterator begin() const { return iterator(*this, 0); }
    iterator end() const { return iterator(*this, size()); }
    
    void dump(PrintStream&) const;
    
private:
    const SwitchValue* m_switch { nullptr };
    const BasicBlock* m_owner { nullptr };
};

} } // namespace JSC::B3

#endif // ENABLE(B3_JIT)

#endif // B3CaseCollection_h




/*
 * Copyright (C) 2016 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 B3CaseCollectionInlines_h
#define B3CaseCollectionInlines_h

#if ENABLE(B3_JIT)

#include "B3CaseCollection.h"
#include "B3SwitchValue.h"
#include "B3BasicBlock.h"

namespace JSC { namespace B3 {

inline const FrequentedBlock& CaseCollection::fallThrough() const
{
    return m_owner->fallThrough();
}

inline unsigned CaseCollection::size() const
{
    return m_switch->numCaseValues();
}

inline SwitchCase CaseCollection::at(unsigned index) const
{
    return SwitchCase(m_switch->caseValue(index), m_owner->successor(index));
}

} } // namespace JSC::B3

#endif // ENABLE(B3_JIT)

#endif // B3CaseCollectionInlines_h




    , m_stackmapRole(stackmapRole)
    , m_numCheckArgs(numArgs)
{
    ASSERT(isDefinitelyTerminal(opcode));
}

CheckSpecial::CheckSpecial(const CheckSpecial::Key& key)

    hiddenBranch.args.reserveInitialCapacity(m_numCheckArgs);
    for (unsigned i = 0; i < m_numCheckArgs; ++i)
        hiddenBranch.args.append(inst.args[i + 1]);
    ASSERT(hiddenBranch.isTerminal());
    return hiddenBranch;
}


Lines 1-5 Source/JavaScriptCore/b3/B3Common.h_sec1
- Source/JavaScriptCore/b3/B3Common.h -2 / +4 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 28-33 Source/JavaScriptCore/b3/B3Common.h_sec2
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
		31	#include "JSExportMacros.h"
		32
31	namespace JSC { namespace B3 {	33	namespace JSC { namespace B3 {
32		34
33	inline bool is64Bit() { return sizeof(void*) == 8; }	35	inline bool is64Bit() { return sizeof(void*) == 8; }
Lines 38-44 enum B3ComplitationMode { Source/JavaScriptCore/b3/B3Common.h_sec3
38	AirMode	40	AirMode
39	};	41	};
40		42
41	bool shouldDumpIR(B3ComplitationMode);	43	JS_EXPORT_PRIVATE bool shouldDumpIR(B3ComplitationMode);
42	bool shouldDumpIRAtEachPhase(B3ComplitationMode);	44	bool shouldDumpIRAtEachPhase(B3ComplitationMode);
43	bool shouldValidateIR();	45	bool shouldValidateIR();
44	bool shouldValidateIRAtEachPhase();	46	bool shouldValidateIRAtEachPhase();



/*
 * Copyright (C) 2015-2016 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 "B3ControlValue.h"

#if ENABLE(B3_JIT)

#include "B3BasicBlock.h"

namespace JSC { namespace B3 {

ControlValue::~ControlValue()
{
}

bool ControlValue::replaceSuccessor(BasicBlock* from, BasicBlock* to)
{
    bool result = false;
    for (FrequentedBlock& successor : m_successors) {
        if (successor.block() == from) {
            successor.block() = to;
            result = true;

            // Keep looping because it's valid for a successor to be mentioned multiple times,
            // like if multiple switch cases have the same target.
        }
    }
    return result;
}

void ControlValue::convertToJump(BasicBlock* destination)
{
    unsigned index = this->index();
    Origin origin = this->origin();
    BasicBlock* owner = this->owner;

    this->~ControlValue();

    new (this) ControlValue(Jump, origin, FrequentedBlock(destination));

    this->owner = owner;
    this->m_index = index;
}

void ControlValue::convertToOops()
{
    unsigned index = this->index();
    Origin origin = this->origin();
    BasicBlock* owner = this->owner;

    this->~ControlValue();

    new (this) ControlValue(Oops, origin);

    this->owner = owner;
    this->m_index = index;
}

void ControlValue::dumpMeta(CommaPrinter& comma, PrintStream& out) const
{
    for (FrequentedBlock successor : m_successors)
        out.print(comma, successor);
}

Value* ControlValue::cloneImpl() const
{
    return new ControlValue(*this);
}

} } // namespace JSC::B3

#endif // ENABLE(B3_JIT)



/*
 * Copyright (C) 2015-2016 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 B3ControlValue_h
#define B3ControlValue_h

#if ENABLE(B3_JIT)

#include "B3FrequentedBlock.h"
#include "B3SuccessorCollection.h"
#include "B3Value.h"

namespace JSC { namespace B3 {

class BasicBlock;

class JS_EXPORT_PRIVATE ControlValue : public Value {
public:
    static bool accepts(Opcode opcode)
    {
        switch (opcode) {
        case Jump:
        case Branch:
        case Return:
        case Oops:
            return true;
        case Switch: 
            // This is here because SwitchValue is a subclass of ControlValue, so we want
            // switchValue->as<ControlValue>() to return non-null.
            return true;
        default:
            return false;
        }
    }

    typedef Vector<FrequentedBlock, 2> SuccessorList;

    ~ControlValue();

    unsigned numSuccessors() const { return m_successors.size(); }
    const FrequentedBlock& successor(unsigned index) const { return m_successors[index]; }
    FrequentedBlock& successor(unsigned index) { return m_successors[index]; }
    const SuccessorList& successors() const { return m_successors; }
    SuccessorList& successors() { return m_successors; }

    BasicBlock* successorBlock(unsigned index) const { return successor(index).block(); }
    BasicBlock*& successorBlock(unsigned index) { return successor(index).block(); }
    SuccessorCollection<BasicBlock, SuccessorList> successorBlocks()
    {
        return SuccessorCollection<BasicBlock, SuccessorList>(successors());
    }
    SuccessorCollection<const BasicBlock, const SuccessorList> successorBlocks() const
    {
        return SuccessorCollection<const BasicBlock, const SuccessorList>(successors());
    }

    bool replaceSuccessor(BasicBlock* from, BasicBlock* to);

    const FrequentedBlock& taken() const
    {
        ASSERT(opcode() == Jump || opcode() == Branch);
        return successor(0);
    }
    FrequentedBlock& taken()
    {
        ASSERT(opcode() == Jump || opcode() == Branch);
        return successor(0);
    }
    const FrequentedBlock& notTaken() const
    {
        ASSERT(opcode() == Branch);
        return successor(1);
    }
    FrequentedBlock& notTaken()
    {
        ASSERT(opcode() == Branch);
        return successor(1);
    }

    void convertToJump(BasicBlock* destination);
    void convertToOops();

protected:
    void dumpMeta(CommaPrinter&, PrintStream&) const override;

    Value* cloneImpl() const override;

    // Use this for subclasses.
    template<typename... Arguments>
    ControlValue(Opcode opcode, Type type, Origin origin, Arguments... arguments)
        : Value(CheckedOpcode, opcode, type, origin, arguments...)
    {
        ASSERT(accepts(opcode));
    }

    // Subclasses will populate this.
    SuccessorList m_successors;

private:
    friend class Procedure;

    // Use this for Oops.
    ControlValue(Opcode opcode, Origin origin)
        : Value(CheckedOpcode, opcode, Void, origin)
    {
        ASSERT(opcode == Oops);
    }

    // Use this for Return.
    ControlValue(Opcode opcode, Origin origin, Value* result)
        : Value(CheckedOpcode, opcode, Void, origin, result)
    {
        ASSERT(opcode == Return);
    }

    // Use this for Jump.
    ControlValue(Opcode opcode, Origin origin, const FrequentedBlock& target)
        : Value(CheckedOpcode, opcode, Void, origin)
    {
        ASSERT(opcode == Jump);
        m_successors.append(target);
    }

    // Use this for Branch.
    ControlValue(
        Opcode opcode, Origin origin, Value* predicate,
        const FrequentedBlock& yes, const FrequentedBlock& no)
        : Value(CheckedOpcode, opcode, Void, origin, predicate)
    {
        ASSERT(opcode == Branch);
        m_successors.append(yes);
        m_successors.append(no);
    }
};

} } // namespace JSC::B3

#endif // ENABLE(B3_JIT)

#endif // B3ControlValue_h




/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

namespace JSC { namespace B3 {

DataSection::DataSection(size_t size)
    : m_data(fastZeroedMalloc(size))
    , m_size(size)
{
}




#include "B3BasicBlockInlines.h"
#include "B3BreakCriticalEdges.h"
#include "B3ControlValue.h"
#include "B3Dominators.h"
#include "B3FixSSA.h"
#include "B3IndexSet.h"

        IndexSet<BasicBlock> candidates;

        for (BasicBlock* block : m_proc) {
            if (block->size() > m_maxSize
                || block->numSuccessors() > m_maxSuccessors)
                continue;
            
            candidates.add(block);
        }


        }

        for (BasicBlock* block : m_proc) {
            if (block->last()->opcode() != Jump)
            if (jump->opcode() != Jump)
                continue;

            BasicBlock* tail = block->successorBlock(0);
            if (!candidates.contains(tail))
                continue;


                    map.add(value, clone);
                block->append(clone);
            }
            block->successors() = tail->successors();
        }

        m_proc.resetReachability();

Lines 30-36 Source/JavaScriptCore/b3/B3FixSSA.cpp_sec1
- Source/JavaScriptCore/b3/B3FixSSA.cpp -1 lines
30		30
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3BreakCriticalEdges.h"	32	#include "B3BreakCriticalEdges.h"
33	#include "B3ControlValue.h"
34	#include "B3Dominators.h"	33	#include "B3Dominators.h"
35	#include "B3IndexSet.h"	34	#include "B3IndexSet.h"
36	#include "B3InsertionSetInlines.h"	35	#include "B3InsertionSetInlines.h"



#if ENABLE(B3_JIT)

#include "B3BasicBlockInlines.h"
#include "B3CaseCollectionInlines.h"
#include "B3Dominators.h"
#include "B3InsertionSetInlines.h"
#include "B3PhaseScope.h"

        };
        
        for (BasicBlock* block : m_proc) {
            Value* branch = block->last();
            switch (branch->opcode()) {
            case Branch:
                if (block->successorBlock(0) == block->successorBlock(1))
                    continue;
                addOverride(
                    block, branch->child(0),
                    Override::nonZero(block->successorBlock(0)));
                addOverride(
                    block, branch->child(0),
                    Override::constant(block->successorBlock(1), 0));
                break;
            case Switch: {
                HashMap<BasicBlock*, unsigned> targetUses;
                for (const SwitchCase& switchCase : branch->as<SwitchValue>()->cases(block))
                    targetUses.add(switchCase.targetBlock(), 0).iterator->value++;

                for (const SwitchCase& switchCase : branch->as<SwitchValue>()->cases(block)) {
                    if (targetUses.find(switchCase.targetBlock())->value != 1)
                        continue;



                switch (value->opcode()) {
                case Branch: {
                    if (getOverride(block, value->child(0)).isNonZero) {
                        value->replaceWithJump(block, block->taken());
                        branch->convertToJump(branch->taken().block());
                        changed = true;
                    }
                    break;

Lines 1-5 Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec1
- Source/JavaScriptCore/b3/B3LowerMacros.cpp -43 / +145 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 28-44 Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec2
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
		31	#include "AllowMacroScratchRegisterUsage.h"
31	#include "B3BasicBlockInlines.h"	32	#include "B3BasicBlockInlines.h"
32	#include "B3BlockInsertionSet.h"	33	#include "B3BlockInsertionSet.h"
33	#include "B3CCallValue.h"	34	#include "B3CCallValue.h"
		35	#include "B3CaseCollectionInlines.h"
34	#include "B3ConstPtrValue.h"	36	#include "B3ConstPtrValue.h"
35	#include "B3ControlValue.h"
36	#include "B3InsertionSetInlines.h"	37	#include "B3InsertionSetInlines.h"
		38	#include "B3MemoryValue.h"
		39	#include "B3PatchpointValue.h"
37	#include "B3PhaseScope.h"	40	#include "B3PhaseScope.h"
38	#include "B3ProcedureInlines.h"	41	#include "B3ProcedureInlines.h"
		42	#include "B3StackmapGenerationParams.h"
39	#include "B3SwitchValue.h"	43	#include "B3SwitchValue.h"
40	#include "B3UpsilonValue.h"	44	#include "B3UpsilonValue.h"
41	#include "B3ValueInlines.h"	45	#include "B3ValueInlines.h"
		46	#include "CCallHelpers.h"
		47	#include "LinkBuffer.h"
42	#include <cmath>	48	#include <cmath>
43		49
44	namespace JSC { namespace B3 {	50	namespace JSC { namespace B3 {
Lines 118-125 private: Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec3
118	BasicBlock* zeroDenCase = m_blockInsertionSet.insertBefore(m_block);	124	BasicBlock* zeroDenCase = m_blockInsertionSet.insertBefore(m_block);
119	BasicBlock* normalModCase = m_blockInsertionSet.insertBefore(m_block);	125	BasicBlock* normalModCase = m_blockInsertionSet.insertBefore(m_block);
120		126
121	before->replaceLastWithNew<ControlValue>(	127	before->replaceLastWithNew<Value>(m_proc, Branch, m_origin, m_value->child(1));
122	m_proc, Branch, m_origin, m_value->child(1),	128	before->setSuccessors(
123	FrequentedBlock(normalModCase, FrequencyClass::Normal),	129	FrequentedBlock(normalModCase, FrequencyClass::Normal),
124	FrequentedBlock(zeroDenCase, FrequencyClass::Rare));	130	FrequentedBlock(zeroDenCase, FrequencyClass::Rare));
125		131
Lines 127-138 private: Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec4
127	Value* multipliedBack = normalModCase->appendNew<Value>(m_proc, Mul, m_origin, divResult, m_value->child(1));	133	Value* multipliedBack = normalModCase->appendNew<Value>(m_proc, Mul, m_origin, divResult, m_value->child(1));
128	Value* result = normalModCase->appendNew<Value>(m_proc, Sub, m_origin, m_value->child(0), multipliedBack);	134	Value* result = normalModCase->appendNew<Value>(m_proc, Sub, m_origin, m_value->child(0), multipliedBack);
129	UpsilonValue* normalResult = normalModCase->appendNew<UpsilonValue>(m_proc, m_origin, result);	135	UpsilonValue* normalResult = normalModCase->appendNew<UpsilonValue>(m_proc, m_origin, result);
130	normalModCase->appendNew<ControlValue>(m_proc, Jump, m_origin, FrequentedBlock(m_block));	136	normalModCase->appendNew<Value>(m_proc, Jump, m_origin);
		137	normalModCase->setSuccessors(FrequentedBlock(m_block));
131		138
132	UpsilonValue* zeroResult = zeroDenCase->appendNew<UpsilonValue>(	139	UpsilonValue* zeroResult = zeroDenCase->appendNew<UpsilonValue>(
133	m_proc, m_origin,	140	m_proc, m_origin,
134	zeroDenCase->appendIntConstant(m_proc, m_value, 0));	141	zeroDenCase->appendIntConstant(m_proc, m_value, 0));
135	zeroDenCase->appendNew<ControlValue>(m_proc, Jump, m_origin, FrequentedBlock(m_block));	142	zeroDenCase->appendNew<Value>(m_proc, Jump, m_origin);
		143	zeroDenCase->setSuccessors(FrequentedBlock(m_block));
136		144
137	Value* phi = m_insertionSet.insert<Value>(m_index, Phi, m_value->type(), m_origin);	145	Value* phi = m_insertionSet.insert<Value>(m_index, Phi, m_value->type(), m_origin);
138	normalResult->setPhi(phi);	146	normalResult->setPhi(phi);
Lines 147-161 private: Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec5
147	case Switch: {	155	case Switch: {
148	SwitchValue* switchValue = m_value->as<SwitchValue>();	156	SwitchValue* switchValue = m_value->as<SwitchValue>();
149	Vector<SwitchCase> cases;	157	Vector<SwitchCase> cases;
150	for (const SwitchCase& switchCase : *switchValue)	158	for (const SwitchCase& switchCase : switchValue->cases(m_block))
151	cases.append(switchCase);	159	cases.append(switchCase);
152	std::sort(	160	std::sort(
153	cases.begin(), cases.end(),	161	cases.begin(), cases.end(),
154	[] (const SwitchCase& left, const SwitchCase& right) {	162	[] (const SwitchCase& left, const SwitchCase& right) {
155	return left.caseValue() < right.caseValue();	163	return left.caseValue() < right.caseValue();
156	});	164	});
		165	FrequentedBlock fallThrough = m_block->fallThrough();
157	m_block->values().removeLast();	166	m_block->values().removeLast();
158	recursivelyBuildSwitch(cases, 0, false, cases.size(), m_block);	167	recursivelyBuildSwitch(cases, fallThrough, 0, false, cases.size(), m_block);
159	m_proc.deleteValue(switchValue);	168	m_proc.deleteValue(switchValue);
160	m_block->updatePredecessorsAfter();	169	m_block->updatePredecessorsAfter();
161	m_changed = true;	170	m_changed = true;
Lines 210-236 private: Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec6
210	BasicBlock* neg1DenCase = m_blockInsertionSet.insertBefore(m_block);	219	BasicBlock* neg1DenCase = m_blockInsertionSet.insertBefore(m_block);
211	BasicBlock* intMinCase = m_blockInsertionSet.insertBefore(m_block);	220	BasicBlock* intMinCase = m_blockInsertionSet.insertBefore(m_block);
212		221
213	before->replaceLastWithNew<ControlValue>(	222	before->replaceLastWithNew<Value>(m_proc, Branch, m_origin, isDenOK);
214	m_proc, Branch, m_origin, isDenOK,	223	before->setSuccessors(
215	FrequentedBlock(normalDivCase, FrequencyClass::Normal),	224	FrequentedBlock(normalDivCase, FrequencyClass::Normal),
216	FrequentedBlock(shadyDenCase, FrequencyClass::Rare));	225	FrequentedBlock(shadyDenCase, FrequencyClass::Rare));
217		226
218	UpsilonValue* normalResult = normalDivCase->appendNew<UpsilonValue>(	227	UpsilonValue* normalResult = normalDivCase->appendNew<UpsilonValue>(
219	m_proc, m_origin,	228	m_proc, m_origin,
220	normalDivCase->appendNew<Value>(m_proc, nonChillOpcode, m_origin, num, den));	229	normalDivCase->appendNew<Value>(m_proc, nonChillOpcode, m_origin, num, den));
221	normalDivCase->appendNew<ControlValue>(	230	normalDivCase->appendNew<Value>(m_proc, Jump, m_origin);
222	m_proc, Jump, m_origin, FrequentedBlock(m_block));	231	normalDivCase->setSuccessors(FrequentedBlock(m_block));
223		232
224	shadyDenCase->appendNew<ControlValue>(	233	shadyDenCase->appendNew<Value>(m_proc, Branch, m_origin, den);
225	m_proc, Branch, m_origin, den,	234	shadyDenCase->setSuccessors(
226	FrequentedBlock(neg1DenCase, FrequencyClass::Normal),	235	FrequentedBlock(neg1DenCase, FrequencyClass::Normal),
227	FrequentedBlock(zeroDenCase, FrequencyClass::Rare));	236	FrequentedBlock(zeroDenCase, FrequencyClass::Rare));
228		237
229	UpsilonValue* zeroResult = zeroDenCase->appendNew<UpsilonValue>(	238	UpsilonValue* zeroResult = zeroDenCase->appendNew<UpsilonValue>(
230	m_proc, m_origin,	239	m_proc, m_origin,
231	zeroDenCase->appendIntConstant(m_proc, m_value, 0));	240	zeroDenCase->appendIntConstant(m_proc, m_value, 0));
232	zeroDenCase->appendNew<ControlValue>(	241	zeroDenCase->appendNew<Value>(m_proc, Jump, m_origin);
233	m_proc, Jump, m_origin, FrequentedBlock(m_block));	242	zeroDenCase->setSuccessors(FrequentedBlock(m_block));
234		243
235	int64_t badNumeratorConst = 0;	244	int64_t badNumeratorConst = 0;
236	switch (m_value->type()) {	245	switch (m_value->type()) {
Lines 248-265 private: Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec7
248	Value* badNumerator =	257	Value* badNumerator =
249	neg1DenCase->appendIntConstant(m_proc, m_value, badNumeratorConst);	258	neg1DenCase->appendIntConstant(m_proc, m_value, badNumeratorConst);
250		259
251	neg1DenCase->appendNew<ControlValue>(	260	neg1DenCase->appendNew<Value>(
252	m_proc, Branch, m_origin,	261	m_proc, Branch, m_origin,
253	neg1DenCase->appendNew<Value>(	262	neg1DenCase->appendNew<Value>(
254	m_proc, Equal, m_origin, num, badNumerator),	263	m_proc, Equal, m_origin, num, badNumerator));
		264	neg1DenCase->setSuccessors(
255	FrequentedBlock(intMinCase, FrequencyClass::Rare),	265	FrequentedBlock(intMinCase, FrequencyClass::Rare),
256	FrequentedBlock(normalDivCase, FrequencyClass::Normal));	266	FrequentedBlock(normalDivCase, FrequencyClass::Normal));
257		267
258	Value* intMinResult = nonChillOpcode == Div ? badNumerator : intMinCase->appendIntConstant(m_proc, m_value, 0);	268	Value* intMinResult = nonChillOpcode == Div ? badNumerator : intMinCase->appendIntConstant(m_proc, m_value, 0);
259	UpsilonValue* intMinResultUpsilon = intMinCase->appendNew<UpsilonValue>(	269	UpsilonValue* intMinResultUpsilon = intMinCase->appendNew<UpsilonValue>(
260	m_proc, m_origin, intMinResult);	270	m_proc, m_origin, intMinResult);
261	intMinCase->appendNew<ControlValue>(	271	intMinCase->appendNew<Value>(m_proc, Jump, m_origin);
262	m_proc, Jump, m_origin, FrequentedBlock(m_block));	272	intMinCase->setSuccessors(FrequentedBlock(m_block));
263		273
264	Value* phi = m_insertionSet.insert<Value>(	274	Value* phi = m_insertionSet.insert<Value>(
265	m_index, Phi, m_value->type(), m_origin);	275	m_index, Phi, m_value->type(), m_origin);
Lines 272-282 private: Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec8
272	}	282	}
273		283
274	void recursivelyBuildSwitch(	284	void recursivelyBuildSwitch(
275	const Vector<SwitchCase>& cases, unsigned start, bool hardStart, unsigned end,	285	const Vector<SwitchCase>& cases, FrequentedBlock fallThrough, unsigned start, bool hardStart,
276	BasicBlock* before)	286	unsigned end, BasicBlock* before)
277	{	287	{
278	// FIXME: Add table-based switch lowering.	288	Value* child = m_value->child(0);
279	// https://bugs.webkit.org/show_bug.cgi?id=151141	289	Type type = child->type();
		290
		291	// It's a good idea to use a table-based switch in some cases: the number of cases has to be
		292	// large enough and they have to be dense enough. This could probably be improved a lot. For
		293	// example, we could still use a jump table in cases where the inputs are sparse so long as we
		294	// shift off the uninteresting bits. On the other hand, it's not clear that this would
		295	// actually be any better than what we have done here and it's not clear that it would be
		296	// better than a binary switch.
		297	const unsigned minCasesForTable = 7;
		298	const unsigned densityLimit = 4;
		299	if (end - start >= minCasesForTable) {
		300	int64_t firstValue = cases[start].caseValue();
		301	int64_t lastValue = cases[end - 1].caseValue();
		302	if ((lastValue - firstValue + 1) / cases.size() < densityLimit) {
		303	BasicBlock* switchBlock = m_blockInsertionSet.insertAfter(m_block);
		304	Value* index = before->appendNew<Value>(
		305	m_proc, Sub, m_origin, child,
		306	before->appendIntConstant(m_proc, m_origin, type, firstValue));
		307	before->appendNew<Value>(
		308	m_proc, Branch, m_origin,
		309	before->appendNew<Value>(
		310	m_proc, Above, m_origin, index,
		311	before->appendIntConstant(m_proc, m_origin, type, lastValue - firstValue)));
		312	before->setSuccessors(fallThrough, FrequentedBlock(switchBlock));
		313
		314	size_t tableSize = lastValue - firstValue + 1;
		315
		316	if (index->type() != pointerType() && index->type() == Int32)
		317	index = switchBlock->appendNew<Value>(m_proc, ZExt32, m_origin, index);
		318
		319	PatchpointValue* patchpoint =
		320	switchBlock->appendNew<PatchpointValue>(m_proc, Void, m_origin);
		321
		322	patchpoint->effects.terminal = true;
		323	patchpoint->appendSomeRegister(index);
		324	patchpoint->numGPScratchRegisters++;
		325	// Technically, we don't have to clobber macro registers on X86_64. This is probably
		326	// OK though.
		327	patchpoint->clobber(RegisterSet::macroScratchRegisters());
		328
		329	BitVector handledIndices;
		330	for (unsigned i = start; i < end; ++i) {
		331	FrequentedBlock block = cases[i].target();
		332	int64_t value = cases[i].caseValue();
		333	switchBlock->appendSuccessor(block);
		334	size_t index = value - firstValue;
		335	ASSERT(!handledIndices.get(index));
		336	handledIndices.set(index);
		337	}
		338
		339	bool hasUnhandledIndex = false;
		340	for (unsigned i = 0; i < tableSize; ++i) {
		341	if (!handledIndices.get(i)) {
		342	hasUnhandledIndex = true;
		343	break;
		344	}
		345	}
		346
		347	if (hasUnhandledIndex)
		348	switchBlock->appendSuccessor(fallThrough);
		349
		350	patchpoint->setGenerator(
		351	[=] (CCallHelpers& jit, const StackmapGenerationParams& params) {
		352	AllowMacroScratchRegisterUsage allowScratch(jit);
		353
354	MacroAssemblerCodePtr* jumpTable = static_cast<MacroAssemblerCodePtr*>(
355	params.proc().addDataSection(sizeof(MacroAssemblerCodePtr) * tableSize));
356
357	GPRReg index = params[0].gpr();
358	GPRReg scratch = params.gpScratch(0);
359
360	jit.move(CCallHelpers::TrustedImmPtr(jumpTable), scratch);
361	jit.jump(CCallHelpers::BaseIndex(scratch, index, CCallHelpers::timesPtr()));
362
363	Vector<Box<CCallHelpers::Label>> labels = params.successorLabels();
364
365	jit.addLinkTask(
366	[=] (LinkBuffer& linkBuffer) {
367	if (hasUnhandledIndex) {
368	MacroAssemblerCodePtr fallThrough =
369	linkBuffer.locationOf(*labels.last());
370	for (unsigned i = tableSize; i--;)
371	jumpTable[i] = fallThrough;
372	}
373
374	unsigned labelIndex = 0;
375	for (unsigned tableIndex : handledIndices) {
376	jumpTable[tableIndex] =
377	linkBuffer.locationOf(*labels[labelIndex++]);
378	}
379	});
380	});
381	return;
382	}
383	}
280		384
281	// See comments in jit/BinarySwitch.cpp for a justification of this algorithm. The only	385	// See comments in jit/BinarySwitch.cpp for a justification of this algorithm. The only
282	// thing we do differently is that we don't use randomness.	386	// thing we do differently is that we don't use randomness.
Lines 304-328 private: Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec9
304		408
305	for (unsigned i = 0; i < limit; ++i) {	409	for (unsigned i = 0; i < limit; ++i) {
306	BasicBlock* nextCheck = m_blockInsertionSet.insertAfter(m_block);	410	BasicBlock* nextCheck = m_blockInsertionSet.insertAfter(m_block);
307	before->appendNew<ControlValue>(	411	before->appendNew<Value>(
308	m_proc, Branch, m_origin,	412	m_proc, Branch, m_origin,
309	before->appendNew<Value>(	413	before->appendNew<Value>(
310	m_proc, Equal, m_origin, m_value->child(0),	414	m_proc, Equal, m_origin, child,
311	before->appendIntConstant(	415	before->appendIntConstant(
312	m_proc, m_origin, m_value->child(0)->type(),	416	m_proc, m_origin, type,
313	cases[start + i].caseValue())),	417	cases[start + i].caseValue())));
314	cases[start + i].target(), FrequentedBlock(nextCheck));	418	before->setSuccessors(cases[start + i].target(), FrequentedBlock(nextCheck));
315		419
316	before = nextCheck;	420	before = nextCheck;
317	}	421	}
318		422
319	if (allConsecutive) {	423	before->appendNew<Value>(m_proc, Jump, m_origin);
320	before->appendNew<ControlValue>(	424	if (allConsecutive)
321	m_proc, Jump, m_origin, cases[end - 1].target());	425	before->setSuccessors(cases[end - 1].target());
322	} else {	426	else
323	before->appendNew<ControlValue>(	427	before->setSuccessors(fallThrough);
324	m_proc, Jump, m_origin, m_value->as<SwitchValue>()->fallThrough());
325	}
326	return;	428	return;
327	}	429	}
328		430
Lines 331-347 private: Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec10
331	BasicBlock* left = m_blockInsertionSet.insertAfter(m_block);	433	BasicBlock* left = m_blockInsertionSet.insertAfter(m_block);
332	BasicBlock* right = m_blockInsertionSet.insertAfter(m_block);	434	BasicBlock* right = m_blockInsertionSet.insertAfter(m_block);
333		435
334	before->appendNew<ControlValue>(	436	before->appendNew<Value>(
335	m_proc, Branch, m_origin,	437	m_proc, Branch, m_origin,
336	before->appendNew<Value>(	438	before->appendNew<Value>(
337	m_proc, LessThan, m_origin, m_value->child(0),	439	m_proc, LessThan, m_origin, child,
338	before->appendIntConstant(	440	before->appendIntConstant(
339	m_proc, m_origin, m_value->child(0)->type(),	441	m_proc, m_origin, type,
340	cases[medianIndex].caseValue())),	442	cases[medianIndex].caseValue())));
341	FrequentedBlock(left), FrequentedBlock(right));	443	before->setSuccessors(FrequentedBlock(left), FrequentedBlock(right));
342		444
343	recursivelyBuildSwitch(cases, start, hardStart, medianIndex, left);	445	recursivelyBuildSwitch(cases, fallThrough, start, hardStart, medianIndex, left);
344	recursivelyBuildSwitch(cases, medianIndex, true, end, right);	446	recursivelyBuildSwitch(cases, fallThrough, medianIndex, true, end, right);
345	}	447	}
346		448
347	Procedure& m_proc;	449	Procedure& m_proc;



            }

            // Make sure that the successors are set up correctly.
            ASSERT(block->successors().size() <= 2);
            for (B3::FrequentedBlock successor : block->successors()) {
                m_blockToBlock[block]->successors().append(
                    Air::FrequentedBlock(m_blockToBlock[successor.block()], successor.frequency()));

            }
            return;
        }
            
        case B3::Oops: {
            append(Air::Oops);
            return;



/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

#include "B3Const32Value.h"
#include "B3ConstDoubleValue.h"
#include "B3ConstPtrValue.h"
#include "B3ControlValue.h"
#include "B3UpsilonValue.h"
#include "B3ValueInlines.h"
#include "MathCommon.h"

    Value* shouldGoSlowPath = start->appendNew<Value>(procedure, Above, origin,
        y,
        start->appendNew<Const32Value>(procedure, origin, maxExponentForIntegerMathPow));
    start->appendNew<Value>(procedure, Branch, origin, shouldGoSlowPath);
    start->setSuccessors(FrequentedBlock(functionCallCase), FrequentedBlock(loopPreHeaderCase));
        shouldGoSlowPath,
        FrequentedBlock(functionCallCase), FrequentedBlock(loopPreHeaderCase));

    // Function call.
    Value* yAsDouble = functionCallCase->appendNew<Value>(procedure, IToD, origin, y);

        functionCallCase->appendNew<ConstPtrValue>(procedure, origin, bitwise_cast<void*>(powDouble)),
        x, yAsDouble);
    UpsilonValue* powResultUpsilon = functionCallCase->appendNew<UpsilonValue>(procedure, origin, powResult);
    functionCallCase->appendNew<Value>(procedure, Jump, origin);
    functionCallCase->setSuccessors(FrequentedBlock(continuation));

    // Loop pre-header.
    Value* initialResult = loopPreHeaderCase->appendNew<ConstDoubleValue>(procedure, origin, 1.);

    UpsilonValue* initialResultValue = loopPreHeaderCase->appendNew<UpsilonValue>(procedure, origin, initialResult);
    UpsilonValue* initialSquaredInput = loopPreHeaderCase->appendNew<UpsilonValue>(procedure, origin, x);
    UpsilonValue* initialLoopCounter = loopPreHeaderCase->appendNew<UpsilonValue>(procedure, origin, y);
    loopPreHeaderCase->appendNew<Value>(procedure, Jump, origin);
    loopPreHeaderCase->setSuccessors(FrequentedBlock(loopTestForEvenCase));

    // Test if what is left of the counter is even.
    Value* inLoopCounter = loopTestForEvenCase->appendNew<Value>(procedure, Phi, Int32, origin);

    Value* lastCounterBit = loopTestForEvenCase->appendNew<Value>(procedure, BitAnd, origin,
        inLoopCounter,
        loopTestForEvenCase->appendNew<Const32Value>(procedure, origin, 1));
    loopTestForEvenCase->appendNew<Value>(procedure, Branch, origin, lastCounterBit);
    loopTestForEvenCase->setSuccessors(FrequentedBlock(loopOdd), FrequentedBlock(loopEvenOdd));
        lastCounterBit,
        FrequentedBlock(loopOdd), FrequentedBlock(loopEvenOdd));

    // Counter is odd.
    Value* inLoopResult = loopOdd->appendNew<Value>(procedure, Phi, Double, origin);

    updatedLoopResultUpsilon->setPhi(inLoopResult);
    UpsilonValue* updatedLoopResult = loopOdd->appendNew<UpsilonValue>(procedure, origin, updatedResult);

    loopOdd->appendNew<Value>(procedure, Jump, origin);
    loopOdd->setSuccessors(FrequentedBlock(loopEvenOdd));

    // Even value and following the Odd.
    Value* squaredInput = loopEvenOdd->appendNew<Value>(procedure, Mul, origin, inLoopSquaredInput, inLoopSquaredInput);

    initialLoopCounter->setPhi(inLoopCounter);
    updatedCounterUpsilon->setPhi(inLoopCounter);

    loopEvenOdd->appendNew<Value>(procedure, Branch, origin, updatedCounter);
    loopEvenOdd->setSuccessors(FrequentedBlock(loopTestForEvenCase), FrequentedBlock(continuation));
        updatedCounter,
        FrequentedBlock(loopTestForEvenCase), FrequentedBlock(continuation));

    // Inline loop.
    Value* finalResultPhi = continuation->appendNew<Value>(procedure, Phi, Double, origin);



    Upsilon, // This uses the UpsilonValue class.
    Phi,

    // Jump.
    Jump,
    
    // Polymorphic branch, usable with any integer type. Branches if not equal to zero. The 0-index
    // successor is the true successor.
    Branch,

    // Switch. Switches over either Int32 or Int64. Uses the SwitchValue class.
    Switch,
    
    // Return. Note that B3 procedures don't know their return type, so this can just return any
    // type.
    Return,

    // This is a terminal that indicates that we will never get here.
    Oops
};


    }
}

inline bool isDefinitelyTerminal(Opcode opcode)
{
    switch (opcode) {
    case Jump:
    case Branch:
    case Switch:
    case Oops:
    case Return:
        return true;
    default:
        return false;
    }
}

} } // namespace JSC::B3

namespace WTF {

Lines 146-151 CCallHelpers::Jump PatchpointSpecial::ge Source/JavaScriptCore/b3/B3PatchpointSpecial.cpp_sec1
- Source/JavaScriptCore/b3/B3PatchpointSpecial.cpp +5 lines
146	return CCallHelpers::Jump();	146	return CCallHelpers::Jump();
147	}	147	}
148		148
		149	bool PatchpointSpecial::isTerminal(Inst& inst)
		150	{
		151	return inst.origin->as<PatchpointValue>()->effects.terminal;
		152	}
		153
149	void PatchpointSpecial::dumpImpl(PrintStream& out) const	154	void PatchpointSpecial::dumpImpl(PrintStream& out) const
150	{	155	{
151	out.print("Patchpoint");	156	out.print("Patchpoint");

Lines 1-5 Source/JavaScriptCore/b3/B3PatchpointSpecial.h_sec1
- Source/JavaScriptCore/b3/B3PatchpointSpecial.h -1 / +3 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 56-61 protected: Source/JavaScriptCore/b3/B3PatchpointSpecial.h_sec2
56	// generates the stackmap. Super crazy dude!	56	// generates the stackmap. Super crazy dude!
57		57
58	CCallHelpers::Jump generate(Air::Inst&, CCallHelpers&, Air::GenerationContext&) override;	58	CCallHelpers::Jump generate(Air::Inst&, CCallHelpers&, Air::GenerationContext&) override;
		59
		60	bool isTerminal(Air::Inst&) override;
59		61
60	void dumpImpl(PrintStream&) const override;	62	void dumpImpl(PrintStream&) const override;
61	void deepDumpImpl(PrintStream&) const override;	63	void deepDumpImpl(PrintStream&) const override;




void Procedure::resetReachability()
{
    if (shouldValidateIR()) {
        // Validate the basic properties that we need for resetting reachability. We often reset
        // reachability before IR validation, so without this mini-validation, you would crash inside
        // B3::resetReachability() without getting any IR dump.

        BasicBlock* badBlock = nullptr;
        for (BasicBlock* block : *this) {
            if (!block->size()) {
                badBlock = block;
                break;
            }

            if (!block->last()->as<ControlValue>()) {
                badBlock = block;
                break;
            }
        }

        if (badBlock) {
            dataLog("FATAL: Invalid basic block ", *badBlock, " while running Procedure::resetReachability().\n");
            dataLog(*this);
            RELEASE_ASSERT_NOT_REACHED();
        }
    }
    
    recomputePredecessors(m_blocks);
    
    // The common case is that this does not find any dead blocks.

Lines 218-224 public: Source/JavaScriptCore/b3/B3Procedure.h_sec1
- Source/JavaScriptCore/b3/B3Procedure.h -1 / +4 lines
218		218
219	const char* lastPhaseName() const { return m_lastPhaseName; }	219	const char* lastPhaseName() const { return m_lastPhaseName; }
220		220
221	void* addDataSection(size_t size);	221	// Allocates a slab of memory that will be kept alive by anyone who keeps the resulting code
		222	// alive. Great for compiler-generated data sections, like switch jump tables and constant pools.
		223	// This returns memory that has been zero-initialized.
		224	void* addDataSection(size_t);
222		225
223	OpaqueByproducts& byproducts() { return *m_byproducts; }	226	OpaqueByproducts& byproducts() { return *m_byproducts; }
224		227



#include "B3BasicBlockInlines.h"
#include "B3BlockInsertionSet.h"
#include "B3ComputeDivisionMagic.h"
#include "B3ControlValue.h"
#include "B3Dominators.h"
#include "B3IndexSet.h"
#include "B3InsertionSetInlines.h"

                // Replace the rest of the block with an Oops.
                for (unsigned i = m_index + 1; i < m_block->size() - 1; ++i)
                    m_block->at(i)->replaceWithBottom(m_insertionSet, m_index);
                m_block->last()->replaceWithOops(m_block);
                m_block->last()->setOrigin(checkValue->origin());

                // Replace ourselves last.

                    return value->opcode() == Select
                        && (value->child(1)->isConstant() && value->child(2)->isConstant());
                });
            
            if (select) {
                specializeSelect(select);
                break;

        }

        case Branch: {
            ControlValue* branch = m_value->as<ControlValue>();

            // Turn this: Branch(NotEqual(x, 0))
            // Into this: Branch(x)
            if (m_value->child(0)->opcode() == NotEqual && m_value->child(0)->child(1)->isInt(0)) {
                m_value->child(0) = m_value->child(0)->child(0);
                m_changed = true;
            }

            // Turn this: Branch(Equal(x, 0), then, else)
            // Into this: Branch(x, else, then)
            if (m_value->child(0)->opcode() == Equal && m_value->child(0)->child(1)->isInt(0)) {
                m_value->child(0) = m_value->child(0)->child(0);
                std::swap(m_block->taken(), m_block->notTaken());
                m_changed = true;
            }
            
            // Turn this: Branch(BitXor(bool, 1), then, else)
            // Into this: Branch(bool, else, then)
            if (m_value->child(0)->opcode() == BitXor
                && m_value->child(0)->child(1)->isInt32(1)
                && m_value->child(0)->child(0)->returnsBool()) {
                m_value->child(0) = m_value->child(0)->child(0);
                std::swap(m_block->taken(), m_block->notTaken());
                m_changed = true;
            }

            // Turn this: Branch(BitAnd(bool, xyb1), then, else)
            // Into this: Branch(bool, then, else)
            if (m_value->child(0)->opcode() == BitAnd
                && m_value->child(0)->child(1)->hasInt()
                && m_value->child(0)->child(1)->asInt() & 1
                && m_value->child(0)->child(0)->returnsBool()) {
                m_value->child(0) = m_value->child(0)->child(0);
                m_changed = true;
            }

            TriState triState = m_value->child(0)->asTriState();

            // Turn this: Branch(0, then, else)
            // Into this: Jump(else)
            if (triState == FalseTriState) {
                m_block->taken().block()->removePredecessor(m_block);
                m_value->replaceWithJump(m_block, m_block->notTaken());
                m_changedCFG = true;
                break;
            }

            // Turn this: Branch(not 0, then, else)
            // Into this: Jump(then)
            if (triState == TrueTriState) {
                m_block->notTaken().block()->removePredecessor(m_block);
                m_value->replaceWithJump(m_block, m_block->taken());
                m_changedCFG = true;
                break;
            }

            // of makes sense here because it's cheap, but hacks like this show that we're going
            // to need SCCP.
            Value* check = m_pureCSE.findMatch(
                ValueKey(Check, Void, m_value->child(0)), m_block, *m_dominators);
            if (check) {
                // The Check would have side-exited if child(0) was non-zero. So, it must be
                // zero here.
                m_block->taken().block()->removePredecessor(m_block);
                m_value->replaceWithJump(m_block, m_block->notTaken());
                m_changedCFG = true;
            }
            break;

        // Remove the values from the predecessor.
        predecessor->values().resize(startIndex);
        
        predecessor->appendNew<Value>(m_proc, Branch, source->origin(), predicate);
        predecessor->setSuccessors(FrequentedBlock(cases[0]), FrequentedBlock(cases[1]));
            FrequentedBlock(cases[0]), FrequentedBlock(cases[1]));

        for (unsigned i = 0; i < numCases; ++i) {
            cases[i]->appendNew<Value>(m_proc, Jump, m_value->origin());
            cases[i]->setSuccessors(FrequentedBlock(m_block));
        }

        m_changed = true;

                            dataLog(
                                "Changing ", pointerDump(block), "'s terminal to a Jump.\n");
                        }
                        block->last()->replaceWithJump(block, FrequentedBlock(firstSuccessor));
                        m_changedCFG = true;
                    }
                }

                    // Remove the terminal.
                    Value* value = block->values().takeLast();
                    Origin jumpOrigin = value->origin();
                    RELEASE_ASSERT(value->effects().terminal);
                    m_proc.deleteValue(value);
                    
                    // Append the full contents of the successor to the predecessor.
                    block->values().appendVector(successor->values());
                    block->successors() = successor->successors();
                    
                    // Make sure that the successor has nothing left in it. Make sure that the block
                    // has a terminal so that nobody chokes when they look at it.
                    successor->values().resize(0);
                    successor->appendNew<Value>(m_proc, Oops, jumpOrigin);
                    successor->clearSuccessors();
                    
                    // Ensure that predecessors of block's new successors know what's up.
                    for (BasicBlock* newSuccessor : block->successorBlocks())



/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

    return result;
}

Vector<Box<CCallHelpers::Label>> StackmapGenerationParams::successorLabels() const
{
    RELEASE_ASSERT(m_context.indexInBlock == m_context.currentBlock->size() - 1);
    RELEASE_ASSERT(m_value->effects().terminal);
    
    Vector<Box<CCallHelpers::Label>> result(m_context.currentBlock->numSuccessors());
    for (unsigned i = m_context.currentBlock->numSuccessors(); i--;)
        result[i] = m_context.blockLabels[m_context.currentBlock->successorBlock(i)];
    return result;
}

bool StackmapGenerationParams::fallsThroughToSuccessor(unsigned successorIndex) const
{
    RELEASE_ASSERT(m_context.indexInBlock == m_context.currentBlock->size() - 1);
    RELEASE_ASSERT(m_value->effects().terminal);
    
    Air::BasicBlock* successor = m_context.currentBlock->successorBlock(successorIndex);
    Air::BasicBlock* nextBlock = m_context.code->findNextBlock(m_context.currentBlock);
    return successor == nextBlock;
}

Procedure& StackmapGenerationParams::proc() const
{
    return m_context.code->proc();

Lines 30-36 Source/JavaScriptCore/b3/B3StackmapGenerationParams.h_sec1
- Source/JavaScriptCore/b3/B3StackmapGenerationParams.h +10 lines
30		30
31	#include "AirGenerationContext.h"	31	#include "AirGenerationContext.h"
32	#include "B3ValueRep.h"	32	#include "B3ValueRep.h"
		33	#include "CCallHelpers.h"
33	#include "RegisterSet.h"	34	#include "RegisterSet.h"
		35	#include <wtf/Box.h>
34		36
35	namespace JSC { namespace B3 {	37	namespace JSC { namespace B3 {
36		38
Lines 39-44 class PatchpointSpecial; Source/JavaScriptCore/b3/B3StackmapGenerationParams.h_sec2
39	class Procedure;	41	class Procedure;
40	class StackmapValue;	42	class StackmapValue;
41		43
		44	// NOTE: It's possible to capture StackmapGenerationParams by value, but not all of the methods will
		45	// work if you do that.
42	class StackmapGenerationParams {	46	class StackmapGenerationParams {
43	public:	47	public:
44	// This is the stackmap value that we're generating.	48	// This is the stackmap value that we're generating.
Lines 80-85 public: Source/JavaScriptCore/b3/B3StackmapGenerationParams.h_sec3
80		84
81	GPRReg gpScratch(unsigned index) const { return m_gpScratch[index]; }	85	GPRReg gpScratch(unsigned index) const { return m_gpScratch[index]; }
82	FPRReg fpScratch(unsigned index) const { return m_fpScratch[index]; }	86	FPRReg fpScratch(unsigned index) const { return m_fpScratch[index]; }
		87
		88	// This is computed lazily, so it won't work if you capture StackmapGenerationParams by value.
		89	JS_EXPORT_PRIVATE Vector<Box<CCallHelpers::Label>> successorLabels() const;
		90
		91	// This is computed lazily also.
		92	bool fallsThroughToSuccessor(unsigned successorIndex) const;
83		93
84	// This is provided for convenience; it means that you don't have to capture it if you don't want to.	94	// This is provided for convenience; it means that you don't have to capture it if you don't want to.
85	Procedure& proc() const;	95	Procedure& proc() const;



{
}

SwitchCase SwitchValue::removeCase(BasicBlock* block, unsigned index)
{
    FrequentedBlock resultBlock = block->successor(index);
    int64_t resultValue = m_values[index];
    block->successor(index) = block->successors().last();
    block->successors().removeLast();
    m_values[index] = m_values.last();
    m_values.removeLast();
    return SwitchCase(resultValue, resultBlock);
}

bool SwitchValue::hasFallThrough(const BasicBlock* block) const
{
    unsigned numSuccessors = block->numSuccessors();
    unsigned numValues = m_values.size();
    RELEASE_ASSERT(numValues == numSuccessors || numValues + 1 == numSuccessors);
    
    return numValues + 1 == numSuccessors;
}

bool SwitchValue::hasFallThrough() const
{
    return hasFallThrough(owner);
}

void SwitchValue::setFallThrough(BasicBlock* block, const FrequentedBlock& target)
{
    if (!hasFallThrough())
        block->successors().append(target);
    else
        block->successors().last() = target;
    ASSERT(hasFallThrough(block));
}

void SwitchValue::appendCase(BasicBlock* block, const SwitchCase& switchCase)
{
    if (!hasFallThrough())
        block->successors().append(switchCase.target());
    else {
        block->successors().append(block->successors().last());
        block->successor(block->numSuccessors() - 2) = switchCase.target();
    }
    m_values.append(switchCase.caseValue());
}

void SwitchValue::setFallThrough(const FrequentedBlock& target)
{
    setFallThrough(owner, target);
}

void SwitchValue::appendCase(const SwitchCase& switchCase)
{
    appendCase(owner, switchCase);
}

void SwitchValue::dumpSuccessors(const BasicBlock* block, PrintStream& out) const
{
    // We must not crash due to a number-of-successors mismatch! Someone debugging a
    // number-of-successors bug will want to dump IR!
    if (numCaseValues() + 1 != block->numSuccessors()) {
        Value::dumpSuccessors(block, out);
        return;
    }
    
    out.print(cases(block));
}

void SwitchValue::dumpMeta(CommaPrinter& comma, PrintStream& out) const
{
    out.print(comma, "cases = [", listDump(m_values), "]");
    for (SwitchCase switchCase : *this)
        out.print(comma, switchCase);
    out.print(comma, "fallThrough = ", fallThrough());
}

Value* SwitchValue::cloneImpl() const

    return new SwitchValue(*this);
}

SwitchValue::SwitchValue(Origin origin, Value* child)
    : Value(CheckedOpcode, Switch, Void, origin, child)
{
    m_successors.append(fallThrough);
}

} } // namespace JSC::B3




#if ENABLE(B3_JIT)

#include "B3CaseCollection.h"
#include "B3SwitchCase.h"
#include "B3Value.h"

namespace JSC { namespace B3 {

class SwitchValue : public Value {
public:
    static bool accepts(Opcode opcode) { return opcode == Switch; }


    
    const Vector<int64_t>& caseValues() const { return m_values; }

    CaseCollection cases(const BasicBlock* owner) const { return CaseCollection(this, owner); }
    CaseCollection cases() const { return cases(owner); }

    unsigned size() const { return numCaseValues(); }
    SwitchCase at(unsigned index) const
    {
        return SwitchCase(caseValue(index), successor(index));
    }
    SwitchCase operator[](unsigned index) const
    {
        return at(index);
    }

    class iterator {
    public:
        iterator()
            : m_switch(nullptr)
            , m_index(0)
        {
        }

        iterator(const SwitchValue& switchValue, unsigned index)
            : m_switch(&switchValue)
            , m_index(index)
        {
        }

        SwitchCase operator*()
        {
            return m_switch->at(m_index);
        }

        iterator& operator++()
        {
            m_index++;
            return *this;
        }

        bool operator==(const iterator& other) const
        {
            ASSERT(m_switch == other.m_switch);
            return m_index == other.m_index;
        }

        bool operator!=(const iterator& other) const
        {
            return !(*this == other);
        }

    private:
        const SwitchValue* m_switch;
        unsigned m_index;
    };

    typedef iterator const_iterator;

    iterator begin() const { return iterator(*this, 0); }
    iterator end() const { return iterator(*this, size()); }

    // This removes the case and reorders things a bit. If you're iterating the cases from 0 to N,
    // then you can keep iterating after this so long as you revisit this same index (which will now
    // contain some other case value). This removes the case that was removed.
    SwitchCase removeCase(BasicBlock*, unsigned index);

    bool hasFallThrough(const BasicBlock*) const;
    bool hasFallThrough() const;

    // These two functions can be called in any order.
    void setFallThrough(BasicBlock*, const FrequentedBlock&);
    void appendCase(BasicBlock*, const SwitchCase&);
    
    JS_EXPORT_PRIVATE void setFallThrough(const FrequentedBlock&);
    JS_EXPORT_PRIVATE void appendCase(const SwitchCase&);

    void dumpSuccessors(const BasicBlock*, PrintStream&) const override;

protected:
    void dumpMeta(CommaPrinter&, PrintStream&) const override;


private:
    friend class Procedure;

    JS_EXPORT_PRIVATE SwitchValue(Origin, Value* child);

    Vector<int64_t> m_values;
};



#include "B3Procedure.h"
#include "B3SlotBaseValue.h"
#include "B3StackSlot.h"
#include "B3SwitchValue.h"
#include "B3UpsilonValue.h"
#include "B3ValueInlines.h"
#include "B3Variable.h"

        for (BasicBlock* block : blocks) {
            VALIDATE(block->size() >= 1, ("At ", *block));
            for (unsigned i = 0; i < block->size() - 1; ++i)
                VALIDATE(!block->at(i)->effects().terminal, ("At ", *block->at(i)));
            VALIDATE(block->last()->effects().terminal, ("At ", *block->last()));
            
            for (BasicBlock* successor : block->successorBlocks()) {
                allPredecessors.add(successor, HashSet<BasicBlock*>()).iterator->value.add(block);

                VALIDATE(child->type() != Void, ("At ", *value, "->", *child));
            switch (value->opcode()) {
            case Nop:
            case Jump:
            case Oops:
                VALIDATE(!value->numChildren(), ("At ", *value));
                VALIDATE(value->type() == Void, ("At ", *value));
                break;

                VALIDATE(!value->numChildren(), ("At ", *value));
                VALIDATE(value->type() != Void, ("At ", *value));
                break;
            case Jump:
                VALIDATE(!value->numChildren(), ("At ", *value));
                VALIDATE(value->type() == Void, ("At ", *value));
                VALIDATE(valueOwner.get(value)->numSuccessors() == 1, ("At ", *value));
                break;
            case Oops:
                VALIDATE(!value->numChildren(), ("At ", *value));
                VALIDATE(value->type() == Void, ("At ", *value));
                VALIDATE(!valueOwner.get(value)->numSuccessors(), ("At ", *value));
                break;
            case Return:
                VALIDATE(value->numChildren() == 1, ("At ", *value));
                VALIDATE(value->type() == Void, ("At ", *value));
                VALIDATE(!valueOwner.get(value)->numSuccessors(), ("At ", *value));
                break;
            case Branch:
                VALIDATE(value->numChildren() == 1, ("At ", *value));
                VALIDATE(isInt(value->child(0)->type()), ("At ", *value));
                VALIDATE(value->type() == Void, ("At ", *value));
                VALIDATE(valueOwner.get(value)->numSuccessors() == 2, ("At ", *value));
                break;
            case Switch:
                VALIDATE(value->numChildren() == 1, ("At ", *value));
                VALIDATE(isInt(value->child(0)->type()), ("At ", *value));
                VALIDATE(value->type() == Void, ("At ", *value));
                VALIDATE(value->as<SwitchValue>()->hasFallThrough(valueOwner.get(value)), ("At ", *value));
                // This validates the same thing as hasFallThrough, but more explicitly. We want to
                // make sure that if anyone tries to change the definition of hasFallThrough, they
                // will feel some pain here, since this is fundamental.
                VALIDATE(valueOwner.get(value)->numSuccessors() == value->as<SwitchValue>()->numCaseValues() + 1, ("At ", *value));
                break;
            }




#if ENABLE(B3_JIT)

#include "B3ArgumentRegValue.h"
#include "B3BasicBlockInlines.h"
#include "B3BottomProvider.h"
#include "B3CCallValue.h"
#include "B3ControlValue.h"
#include "B3MemoryValue.h"
#include "B3OriginDump.h"
#include "B3ProcedureInlines.h"

#include "B3ValueKeyInlines.h"
#include "B3VariableValue.h"
#include <wtf/CommaPrinter.h>
#include <wtf/ListDump.h>
#include <wtf/StringPrintStream.h>

namespace JSC { namespace B3 {

    this->m_index = index;
}

void Value::replaceWithJump(BasicBlock* owner, const FrequentedBlock& target)
{
    RELEASE_ASSERT(owner->last() == this);
    
    unsigned index = m_index;
    Origin origin = m_origin;
    
    this->~Value();
    
    new (this) Value(Jump, Void, origin);
    
    this->owner = owner;
    this->m_index = index;
    
    owner->setSuccessors(target);
}

void Value::replaceWithOops(BasicBlock* owner)
{
    RELEASE_ASSERT(owner->last() == this);
    
    unsigned index = m_index;
    Origin origin = m_origin;
    
    this->~Value();
    
    new (this) Value(Oops, Void, origin);
    
    this->owner = owner;
    this->m_index = index;
    
    owner->clearSuccessors();
}

void Value::replaceWithJump(const FrequentedBlock& target)
{
    replaceWithJump(owner, target);
}

void Value::replaceWithOops()
{
    replaceWithOops(owner);
}

void Value::dump(PrintStream& out) const
{
    bool isConstant = false;

    out.print(")");
}

void Value::dumpSuccessors(const BasicBlock* block, PrintStream& out) const
{
    // Note that this must not crash if we have the wrong number of successors, since someone
    // debugging a number-of-successors bug will probably want to dump IR!
    
    if (opcode() == Branch && block->numSuccessors() == 2) {
        out.print("Then:", block->taken(), ", Else:", block->notTaken());
        return;
    }
    
    out.print(listDump(block->successors()));
}

Value* Value::negConstant(Procedure&) const
{
    return nullptr;

        }
        return Void;
    case Nop:
    case Jump:
    case Branch:
    case Return:
    case Oops:
        return Void;
    case Select:
        ASSERT(secondChild);

Lines 30-35 Source/JavaScriptCore/b3/B3Value.h_sec1
- Source/JavaScriptCore/b3/B3Value.h -1 / +16 lines
30		30
31	#include "AirArg.h"	31	#include "AirArg.h"
32	#include "B3Effects.h"	32	#include "B3Effects.h"
		33	#include "B3FrequentedBlock.h"
33	#include "B3Opcode.h"	34	#include "B3Opcode.h"
34	#include "B3Origin.h"	35	#include "B3Origin.h"
35	#include "B3SparseCollection.h"	36	#include "B3SparseCollection.h"
Lines 109-117 public: Source/JavaScriptCore/b3/B3Value.h_sec2
109	void replaceWithNopIgnoringType();	110	void replaceWithNopIgnoringType();
110		111
111	void replaceWithPhi();	112	void replaceWithPhi();
		113
		114	// These transformations are only valid for terminals.
		115	void replaceWithJump(BasicBlock* owner, const FrequentedBlock&);
		116	void replaceWithOops(BasicBlock* owner);
		117
		118	// You can use this form if owners are valid. They're usually not valid.
		119	void replaceWithJump(const FrequentedBlock&);
		120	void replaceWithOops();
112		121
113	void dump(PrintStream&) const;	122	void dump(PrintStream&) const;
114	void deepDump(const Procedure*, PrintStream&) const;	123	void deepDump(const Procedure*, PrintStream&) const;
		124
		125	virtual void dumpSuccessors(const BasicBlock*, PrintStream&) const;
115		126
116	// This is how you cast Values. For example, if you want to do something provided that we have a	127	// This is how you cast Values. For example, if you want to do something provided that we have a
117	// ArgumentRegValue, you can do:	128	// ArgumentRegValue, you can do:
Lines 223-229 public: Source/JavaScriptCore/b3/B3Value.h_sec3
223	bool isLikeNonZero() const { return asTriState() == TrueTriState; }	234	bool isLikeNonZero() const { return asTriState() == TrueTriState; }
224		235
225	Effects effects() const;	236	Effects effects() const;
226		237
227	// This returns a ValueKey that describes that this Value returns when it executes. Returns an	238	// This returns a ValueKey that describes that this Value returns when it executes. Returns an
228	// empty ValueKey if this Value is impure. Note that an operation that returns Void could still	239	// empty ValueKey if this Value is impure. Note that an operation that returns Void could still
229	// have a non-empty ValueKey. This happens for example with Check operations.	240	// have a non-empty ValueKey. This happens for example with Check operations.
Lines 264-269 private: Source/JavaScriptCore/b3/B3Value.h_sec4
264	case FramePointer:	275	case FramePointer:
265	case Nop:	276	case Nop:
266	case Phi:	277	case Phi:
		278	case Jump:
		279	case Oops:
267	if (UNLIKELY(numArgs))	280	if (UNLIKELY(numArgs))
268	badOpcode(opcode, numArgs);	281	badOpcode(opcode, numArgs);
269	break;	282	break;
Lines 284-289 private: Source/JavaScriptCore/b3/B3Value.h_sec5
284	case DoubleToFloat:	297	case DoubleToFloat:
285	case IToF:	298	case IToF:
286	case BitwiseCast:	299	case BitwiseCast:
		300	case Branch:
		301	case Return:
287	if (UNLIKELY(numArgs != 1))	302	if (UNLIKELY(numArgs != 1))
288	badOpcode(opcode, numArgs);	303	badOpcode(opcode, numArgs);
289	break;	304	break;

Lines 33-39 Source/JavaScriptCore/b3/testb3.cpp_sec1
- Source/JavaScriptCore/b3/testb3.cpp -689 / +928 lines
33	#include "B3ComputeDivisionMagic.h"	33	#include "B3ComputeDivisionMagic.h"
34	#include "B3Const32Value.h"	34	#include "B3Const32Value.h"
35	#include "B3ConstPtrValue.h"	35	#include "B3ConstPtrValue.h"
36	#include "B3ControlValue.h"
37	#include "B3Effects.h"	36	#include "B3Effects.h"
38	#include "B3MathExtras.h"	37	#include "B3MathExtras.h"
39	#include "B3MemoryValue.h"	38	#include "B3MemoryValue.h"
Lines 46-52 Source/JavaScriptCore/b3/testb3.cpp_sec2
46	#include "B3UpsilonValue.h"	45	#include "B3UpsilonValue.h"
47	#include "B3Validate.h"	46	#include "B3Validate.h"
48	#include "B3ValueInlines.h"	47	#include "B3ValueInlines.h"
		48	#include "B3VariableValue.h"
49	#include "CCallHelpers.h"	49	#include "CCallHelpers.h"
		50	#include "FPRInfo.h"
		51	#include "GPRInfo.h"
50	#include "InitializeThreading.h"	52	#include "InitializeThreading.h"
51	#include "JSCInlines.h"	53	#include "JSCInlines.h"
52	#include "LinkBuffer.h"	54	#include "LinkBuffer.h"
Lines 54-59 Source/JavaScriptCore/b3/testb3.cpp_sec3
54	#include "VM.h"	56	#include "VM.h"
55	#include <cmath>	57	#include <cmath>
56	#include <string>	58	#include <string>
		59	#include <wtf/ListDump.h>
57	#include <wtf/Lock.h>	60	#include <wtf/Lock.h>
58	#include <wtf/NumberOfCores.h>	61	#include <wtf/NumberOfCores.h>
59	#include <wtf/Threading.h>	62	#include <wtf/Threading.h>
Lines 75-80 using namespace JSC::B3; Source/JavaScriptCore/b3/testb3.cpp_sec4
75		78
76	namespace {	79	namespace {
77		80
		81	bool shouldBeVerbose()
		82	{
		83	return shouldDumpIR(B3Mode);
		84	}
		85
78	StaticLock crashLock;	86	StaticLock crashLock;
79		87
80	// Nothing fancy for now; we just use the existing WTF assertion machinery.	88	// Nothing fancy for now; we just use the existing WTF assertion machinery.
Lines 194-200 void test42() Source/JavaScriptCore/b3/testb3.cpp_sec5
194	Procedure proc;	202	Procedure proc;
195	BasicBlock* root = proc.addBlock();	203	BasicBlock* root = proc.addBlock();
196	Value* const42 = root->appendNew<Const32Value>(proc, Origin(), 42);	204	Value* const42 = root->appendNew<Const32Value>(proc, Origin(), 42);
197	root->appendNew<ControlValue>(proc, Return, Origin(), const42);	205	root->appendNewControlValue(proc, Return, Origin(), const42);
198		206
199	CHECK(compileAndRun<int>(proc) == 42);	207	CHECK(compileAndRun<int>(proc) == 42);
200	}	208	}
Lines 204-210 void testLoad42() Source/JavaScriptCore/b3/testb3.cpp_sec6
204	Procedure proc;	212	Procedure proc;
205	BasicBlock* root = proc.addBlock();	213	BasicBlock* root = proc.addBlock();
206	int x = 42;	214	int x = 42;
207	root->appendNew<ControlValue>(	215	root->appendNewControlValue(
208	proc, Return, Origin(),	216	proc, Return, Origin(),
209	root->appendNew<MemoryValue>(	217	root->appendNew<MemoryValue>(
210	proc, Load, Int32, Origin(),	218	proc, Load, Int32, Origin(),
Lines 220-226 void testLoadWithOffsetImpl(int32_t offs Source/JavaScriptCore/b3/testb3.cpp_sec7
220	BasicBlock* root = proc.addBlock();	228	BasicBlock* root = proc.addBlock();
221	int64_t x = -42;	229	int64_t x = -42;
222	Value* base = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	230	Value* base = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
223	root->appendNew<ControlValue>(	231	root->appendNewControlValue(
224	proc, Return, Origin(),	232	proc, Return, Origin(),
225	root->appendNew<MemoryValue>(	233	root->appendNew<MemoryValue>(
226	proc, Load, Int64, Origin(),	234	proc, Load, Int64, Origin(),
Lines 235-241 void testLoadWithOffsetImpl(int32_t offs Source/JavaScriptCore/b3/testb3.cpp_sec8
235	BasicBlock* root = proc.addBlock();	243	BasicBlock* root = proc.addBlock();
236	int32_t x = -42;	244	int32_t x = -42;
237	Value* base = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	245	Value* base = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
238	root->appendNew<ControlValue>(	246	root->appendNewControlValue(
239	proc, Return, Origin(),	247	proc, Return, Origin(),
240	root->appendNew<MemoryValue>(	248	root->appendNew<MemoryValue>(
241	proc, Load, Int32, Origin(),	249	proc, Load, Int32, Origin(),
Lines 288-294 void testArg(int argument) Source/JavaScriptCore/b3/testb3.cpp_sec9
288	{	296	{
289	Procedure proc;	297	Procedure proc;
290	BasicBlock* root = proc.addBlock();	298	BasicBlock* root = proc.addBlock();
291	root->appendNew<ControlValue>(	299	root->appendNewControlValue(
292	proc, Return, Origin(),	300	proc, Return, Origin(),
293	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	301	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
294		302
Lines 299-305 void testReturnConst64(int64_t value) Source/JavaScriptCore/b3/testb3.cpp_sec10
299	{	307	{
300	Procedure proc;	308	Procedure proc;
301	BasicBlock* root = proc.addBlock();	309	BasicBlock* root = proc.addBlock();
302	root->appendNew<ControlValue>(	310	root->appendNewControlValue(
303	proc, Return, Origin(),	311	proc, Return, Origin(),
304	root->appendNew<Const64Value>(proc, Origin(), value));	312	root->appendNew<Const64Value>(proc, Origin(), value));
305		313
Lines 311-317 void testAddArg(int a) Source/JavaScriptCore/b3/testb3.cpp_sec11
311	Procedure proc;	319	Procedure proc;
312	BasicBlock* root = proc.addBlock();	320	BasicBlock* root = proc.addBlock();
313	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	321	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
314	root->appendNew<ControlValue>(	322	root->appendNewControlValue(
315	proc, Return, Origin(),	323	proc, Return, Origin(),
316	root->appendNew<Value>(proc, Add, Origin(), value, value));	324	root->appendNew<Value>(proc, Add, Origin(), value, value));
317		325
Lines 322-328 void testAddArgs(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec12
322	{	330	{
323	Procedure proc;	331	Procedure proc;
324	BasicBlock* root = proc.addBlock();	332	BasicBlock* root = proc.addBlock();
325	root->appendNew<ControlValue>(	333	root->appendNewControlValue(
326	proc, Return, Origin(),	334	proc, Return, Origin(),
327	root->appendNew<Value>(	335	root->appendNew<Value>(
328	proc, Add, Origin(),	336	proc, Add, Origin(),
Lines 336-342 void testAddArgImm(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec13
336	{	344	{
337	Procedure proc;	345	Procedure proc;
338	BasicBlock* root = proc.addBlock();	346	BasicBlock* root = proc.addBlock();
339	root->appendNew<ControlValue>(	347	root->appendNewControlValue(
340	proc, Return, Origin(),	348	proc, Return, Origin(),
341	root->appendNew<Value>(	349	root->appendNew<Value>(
342	proc, Add, Origin(),	350	proc, Add, Origin(),
Lines 350-356 void testAddImmArg(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec14
350	{	358	{
351	Procedure proc;	359	Procedure proc;
352	BasicBlock* root = proc.addBlock();	360	BasicBlock* root = proc.addBlock();
353	root->appendNew<ControlValue>(	361	root->appendNewControlValue(
354	proc, Return, Origin(),	362	proc, Return, Origin(),
355	root->appendNew<Value>(	363	root->appendNew<Value>(
356	proc, Add, Origin(),	364	proc, Add, Origin(),
Lines 370-376 void testAddArgMem(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec15
370	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	378	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
371	load);	379	load);
372	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	380	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
373	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	381	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
374		382
375	int64_t inputOutput = b;	383	int64_t inputOutput = b;
376	CHECK(!compileAndRun<int64_t>(proc, a, &inputOutput));	384	CHECK(!compileAndRun<int64_t>(proc, a, &inputOutput));
Lines 386-392 void testAddMemArg(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec16
386	Value* result = root->appendNew<Value>(proc, Add, Origin(),	394	Value* result = root->appendNew<Value>(proc, Add, Origin(),
387	load,	395	load,
388	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	396	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
389	root->appendNew<ControlValue>(proc, Return, Origin(), result);	397	root->appendNewControlValue(proc, Return, Origin(), result);
390		398
391	CHECK(compileAndRun<int64_t>(proc, &a, b) == a + b);	399	CHECK(compileAndRun<int64_t>(proc, &a, b) == a + b);
392	}	400	}
Lines 401-407 void testAddImmMem(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec17
401	root->appendNew<Const64Value>(proc, Origin(), a),	409	root->appendNew<Const64Value>(proc, Origin(), a),
402	load);	410	load);
403	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	411	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
404	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	412	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
405		413
406	int64_t inputOutput = b;	414	int64_t inputOutput = b;
407	CHECK(!compileAndRun<int>(proc, &inputOutput));	415	CHECK(!compileAndRun<int>(proc, &inputOutput));
Lines 414-420 void testAddArg32(int a) Source/JavaScriptCore/b3/testb3.cpp_sec18
414	BasicBlock* root = proc.addBlock();	422	BasicBlock* root = proc.addBlock();
415	Value* value = root->appendNew<Value>(proc, Trunc, Origin(),	423	Value* value = root->appendNew<Value>(proc, Trunc, Origin(),
416	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	424	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
417	root->appendNew<ControlValue>(	425	root->appendNewControlValue(
418	proc, Return, Origin(),	426	proc, Return, Origin(),
419	root->appendNew<Value>(proc, Add, Origin(), value, value));	427	root->appendNew<Value>(proc, Add, Origin(), value, value));
420		428
Lines 425-431 void testAddArgs32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec19
425	{	433	{
426	Procedure proc;	434	Procedure proc;
427	BasicBlock* root = proc.addBlock();	435	BasicBlock* root = proc.addBlock();
428	root->appendNew<ControlValue>(	436	root->appendNewControlValue(
429	proc, Return, Origin(),	437	proc, Return, Origin(),
430	root->appendNew<Value>(	438	root->appendNew<Value>(
431	proc, Add, Origin(),	439	proc, Add, Origin(),
Lines 449-455 void testAddArgMem32(int32_t a, int32_t Source/JavaScriptCore/b3/testb3.cpp_sec20
449	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	457	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
450	Value* result = root->appendNew<Value>(proc, Add, Origin(), argument, load);	458	Value* result = root->appendNew<Value>(proc, Add, Origin(), argument, load);
451	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	459	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
452	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	460	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
453		461
454	int32_t inputOutput = b;	462	int32_t inputOutput = b;
455	CHECK(!compileAndRun<int32_t>(proc, a, &inputOutput));	463	CHECK(!compileAndRun<int32_t>(proc, a, &inputOutput));
Lines 465-471 void testAddMemArg32(int32_t a, int32_t Source/JavaScriptCore/b3/testb3.cpp_sec21
465	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),	473	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),
466	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	474	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
467	Value* result = root->appendNew<Value>(proc, Add, Origin(), load, argument);	475	Value* result = root->appendNew<Value>(proc, Add, Origin(), load, argument);
468	root->appendNew<ControlValue>(proc, Return, Origin(), result);	476	root->appendNewControlValue(proc, Return, Origin(), result);
469		477
470	CHECK(compileAndRun<int32_t>(proc, &a, b) == a + b);	478	CHECK(compileAndRun<int32_t>(proc, &a, b) == a + b);
471	}	479	}
Lines 480-486 void testAddImmMem32(int32_t a, int32_t Source/JavaScriptCore/b3/testb3.cpp_sec22
480	root->appendNew<Const32Value>(proc, Origin(), a),	488	root->appendNew<Const32Value>(proc, Origin(), a),
481	load);	489	load);
482	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	490	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
483	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	491	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
484		492
485	int32_t inputOutput = b;	493	int32_t inputOutput = b;
486	CHECK(!compileAndRun<int>(proc, &inputOutput));	494	CHECK(!compileAndRun<int>(proc, &inputOutput));
Lines 495-501 void testAddArgZeroImmZDef() Source/JavaScriptCore/b3/testb3.cpp_sec23
495	proc, Trunc, Origin(),	503	proc, Trunc, Origin(),
496	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	504	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
497	Value* constZero = root->appendNew<Const32Value>(proc, Origin(), 0);	505	Value* constZero = root->appendNew<Const32Value>(proc, Origin(), 0);
498	root->appendNew<ControlValue>(	506	root->appendNewControlValue(
499	proc, Return, Origin(),	507	proc, Return, Origin(),
500	root->appendNew<Value>(	508	root->appendNew<Value>(
501	proc, Add, Origin(),	509	proc, Add, Origin(),
Lines 515-521 void testAddLoadTwice() Source/JavaScriptCore/b3/testb3.cpp_sec24
515	Value* load = root->appendNew<MemoryValue>(	523	Value* load = root->appendNew<MemoryValue>(
516	proc, Load, Int32, Origin(),	524	proc, Load, Int32, Origin(),
517	root->appendNew<ConstPtrValue>(proc, Origin(), &value));	525	root->appendNew<ConstPtrValue>(proc, Origin(), &value));
518	root->appendNew<ControlValue>(	526	root->appendNewControlValue(
519	proc, Return, Origin(),	527	proc, Return, Origin(),
520	root->appendNew<Value>(proc, Add, Origin(), load, load));	528	root->appendNew<Value>(proc, Add, Origin(), load, load));
521		529
Lines 532-538 void testAddArgDouble(double a) Source/JavaScriptCore/b3/testb3.cpp_sec25
532	Procedure proc;	540	Procedure proc;
533	BasicBlock* root = proc.addBlock();	541	BasicBlock* root = proc.addBlock();
534	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	542	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
535	root->appendNew<ControlValue>(	543	root->appendNewControlValue(
536	proc, Return, Origin(),	544	proc, Return, Origin(),
537	root->appendNew<Value>(proc, Add, Origin(), value, value));	545	root->appendNew<Value>(proc, Add, Origin(), value, value));
538		546
Lines 545-551 void testAddArgsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec26
545	BasicBlock* root = proc.addBlock();	553	BasicBlock* root = proc.addBlock();
546	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	554	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
547	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);	555	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
548	root->appendNew<ControlValue>(	556	root->appendNewControlValue(
549	proc, Return, Origin(),	557	proc, Return, Origin(),
550	root->appendNew<Value>(proc, Add, Origin(), valueA, valueB));	558	root->appendNew<Value>(proc, Add, Origin(), valueA, valueB));
551		559
Lines 558-564 void testAddArgImmDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec27
558	BasicBlock* root = proc.addBlock();	566	BasicBlock* root = proc.addBlock();
559	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	567	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
560	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	568	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
561	root->appendNew<ControlValue>(	569	root->appendNewControlValue(
562	proc, Return, Origin(),	570	proc, Return, Origin(),
563	root->appendNew<Value>(proc, Add, Origin(), valueA, valueB));	571	root->appendNew<Value>(proc, Add, Origin(), valueA, valueB));
564		572
Lines 571-577 void testAddImmArgDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec28
571	BasicBlock* root = proc.addBlock();	579	BasicBlock* root = proc.addBlock();
572	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	580	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
573	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	581	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
574	root->appendNew<ControlValue>(	582	root->appendNewControlValue(
575	proc, Return, Origin(),	583	proc, Return, Origin(),
576	root->appendNew<Value>(proc, Add, Origin(), valueA, valueB));	584	root->appendNew<Value>(proc, Add, Origin(), valueA, valueB));
577		585
Lines 584-590 void testAddImmsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec29
584	BasicBlock* root = proc.addBlock();	592	BasicBlock* root = proc.addBlock();
585	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	593	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
586	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	594	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
587	root->appendNew<ControlValue>(	595	root->appendNewControlValue(
588	proc, Return, Origin(),	596	proc, Return, Origin(),
589	root->appendNew<Value>(proc, Add, Origin(), valueA, valueB));	597	root->appendNew<Value>(proc, Add, Origin(), valueA, valueB));
590		598
Lines 600-606 void testAddArgFloat(float a) Source/JavaScriptCore/b3/testb3.cpp_sec30
600	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	608	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
601	Value* result = root->appendNew<Value>(proc, Add, Origin(), floatValue, floatValue);	609	Value* result = root->appendNew<Value>(proc, Add, Origin(), floatValue, floatValue);
602	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	610	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
603	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	611	root->appendNewControlValue(proc, Return, Origin(), result32);
604		612
605		613
606	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a + a)));	614	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a + a)));
Lines 618-624 void testAddArgsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec31
618	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);	626	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);
619	Value* result = root->appendNew<Value>(proc, Add, Origin(), floatValue1, floatValue2);	627	Value* result = root->appendNew<Value>(proc, Add, Origin(), floatValue1, floatValue2);
620	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	628	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
621	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	629	root->appendNewControlValue(proc, Return, Origin(), result32);
622		630
623	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a + b)));	631	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a + b)));
624	}	632	}
Lines 633-639 void testAddArgImmFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec32
633	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);	641	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);
634	Value* result = root->appendNew<Value>(proc, Add, Origin(), floatValue, constValue);	642	Value* result = root->appendNew<Value>(proc, Add, Origin(), floatValue, constValue);
635	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	643	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
636	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	644	root->appendNewControlValue(proc, Return, Origin(), result32);
637		645
638	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a + b)));	646	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a + b)));
639	}	647	}
Lines 648-654 void testAddImmArgFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec33
648	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);	656	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);
649	Value* result = root->appendNew<Value>(proc, Add, Origin(), constValue, floatValue);	657	Value* result = root->appendNew<Value>(proc, Add, Origin(), constValue, floatValue);
650	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	658	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
651	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	659	root->appendNewControlValue(proc, Return, Origin(), result32);
652		660
653	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a + b)));	661	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a + b)));
654	}	662	}
Lines 661-667 void testAddImmsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec34
661	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);	669	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);
662	Value* result = root->appendNew<Value>(proc, Add, Origin(), constValue1, constValue2);	670	Value* result = root->appendNew<Value>(proc, Add, Origin(), constValue1, constValue2);
663	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	671	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
664	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	672	root->appendNewControlValue(proc, Return, Origin(), result32);
665		673
666	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(a + b)));	674	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(a + b)));
667	}	675	}
Lines 677-683 void testAddArgFloatWithUselessDoubleCon Source/JavaScriptCore/b3/testb3.cpp_sec35
677	Value* result = root->appendNew<Value>(proc, Add, Origin(), asDouble, asDouble);	685	Value* result = root->appendNew<Value>(proc, Add, Origin(), asDouble, asDouble);
678	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	686	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
679	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	687	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
680	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	688	root->appendNewControlValue(proc, Return, Origin(), result32);
681		689
682	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a + a)));	690	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a + a)));
683	}	691	}
Lines 697-703 void testAddArgsFloatWithUselessDoubleCo Source/JavaScriptCore/b3/testb3.cpp_sec36
697	Value* result = root->appendNew<Value>(proc, Add, Origin(), asDouble1, asDouble2);	705	Value* result = root->appendNew<Value>(proc, Add, Origin(), asDouble1, asDouble2);
698	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	706	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
699	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	707	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
700	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	708	root->appendNewControlValue(proc, Return, Origin(), result32);
701		709
702	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a + b)));	710	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a + b)));
703	}	711	}
Lines 719-725 void testAddArgsFloatWithEffectfulDouble Source/JavaScriptCore/b3/testb3.cpp_sec37
719	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);	727	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
720	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);	728	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);
721	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	729	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
722	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	730	root->appendNewControlValue(proc, Return, Origin(), result32);
723		731
724	double effect = 0;	732	double effect = 0;
725	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b), &effect), bitwise_cast<int32_t>(a + b)));	733	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b), &effect), bitwise_cast<int32_t>(a + b)));
Lines 732-738 void testMulArg(int a) Source/JavaScriptCore/b3/testb3.cpp_sec38
732	BasicBlock* root = proc.addBlock();	740	BasicBlock* root = proc.addBlock();
733	Value* value = root->appendNew<Value>(	741	Value* value = root->appendNew<Value>(
734	proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	742	proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
735	root->appendNew<ControlValue>(	743	root->appendNewControlValue(
736	proc, Return, Origin(),	744	proc, Return, Origin(),
737	root->appendNew<Value>(proc, Mul, Origin(), value, value));	745	root->appendNew<Value>(proc, Mul, Origin(), value, value));
738		746
Lines 759-765 void testMulArgStore(int a) Source/JavaScriptCore/b3/testb3.cpp_sec39
759	proc, Store, Origin(), mul,	767	proc, Store, Origin(), mul,
760	root->appendNew<ConstPtrValue>(proc, Origin(), &mulSlot));	768	root->appendNew<ConstPtrValue>(proc, Origin(), &mulSlot));
761		769
762	root->appendNew<ControlValue>(	770	root->appendNewControlValue(
763	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	771	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
764		772
765	CHECK(!compileAndRun<int>(proc, a));	773	CHECK(!compileAndRun<int>(proc, a));
Lines 774-780 void testMulAddArg(int a) Source/JavaScriptCore/b3/testb3.cpp_sec40
774	Value* value = root->appendNew<Value>(	782	Value* value = root->appendNew<Value>(
775	proc, Trunc, Origin(),	783	proc, Trunc, Origin(),
776	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	784	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
777	root->appendNew<ControlValue>(	785	root->appendNewControlValue(
778	proc, Return, Origin(),	786	proc, Return, Origin(),
779	root->appendNew<Value>(	787	root->appendNew<Value>(
780	proc, Add, Origin(),	788	proc, Add, Origin(),
Lines 788-794 void testMulArgs(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec41
788	{	796	{
789	Procedure proc;	797	Procedure proc;
790	BasicBlock* root = proc.addBlock();	798	BasicBlock* root = proc.addBlock();
791	root->appendNew<ControlValue>(	799	root->appendNewControlValue(
792	proc, Return, Origin(),	800	proc, Return, Origin(),
793	root->appendNew<Value>(	801	root->appendNew<Value>(
794	proc, Mul, Origin(),	802	proc, Mul, Origin(),
Lines 802-808 void testMulArgImm(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec42
802	{	810	{
803	Procedure proc;	811	Procedure proc;
804	BasicBlock* root = proc.addBlock();	812	BasicBlock* root = proc.addBlock();
805	root->appendNew<ControlValue>(	813	root->appendNewControlValue(
806	proc, Return, Origin(),	814	proc, Return, Origin(),
807	root->appendNew<Value>(	815	root->appendNew<Value>(
808	proc, Mul, Origin(),	816	proc, Mul, Origin(),
Lines 816-822 void testMulImmArg(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec43
816	{	824	{
817	Procedure proc;	825	Procedure proc;
818	BasicBlock* root = proc.addBlock();	826	BasicBlock* root = proc.addBlock();
819	root->appendNew<ControlValue>(	827	root->appendNewControlValue(
820	proc, Return, Origin(),	828	proc, Return, Origin(),
821	root->appendNew<Value>(	829	root->appendNew<Value>(
822	proc, Mul, Origin(),	830	proc, Mul, Origin(),
Lines 830-836 void testMulArgs32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec44
830	{	838	{
831	Procedure proc;	839	Procedure proc;
832	BasicBlock* root = proc.addBlock();	840	BasicBlock* root = proc.addBlock();
833	root->appendNew<ControlValue>(	841	root->appendNewControlValue(
834	proc, Return, Origin(),	842	proc, Return, Origin(),
835	root->appendNew<Value>(	843	root->appendNew<Value>(
836	proc, Mul, Origin(),	844	proc, Mul, Origin(),
Lines 853-859 void testMulLoadTwice() Source/JavaScriptCore/b3/testb3.cpp_sec45
853	Value* load = root->appendNew<MemoryValue>(	861	Value* load = root->appendNew<MemoryValue>(
854	proc, Load, Int32, Origin(),	862	proc, Load, Int32, Origin(),
855	root->appendNew<ConstPtrValue>(proc, Origin(), &value));	863	root->appendNew<ConstPtrValue>(proc, Origin(), &value));
856	root->appendNew<ControlValue>(	864	root->appendNewControlValue(
857	proc, Return, Origin(),	865	proc, Return, Origin(),
858	root->appendNew<Value>(proc, Mul, Origin(), load, load));	866	root->appendNew<Value>(proc, Mul, Origin(), load, load));
859		867
Lines 875-881 void testMulAddArgsLeft() Source/JavaScriptCore/b3/testb3.cpp_sec46
875	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);	883	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
876	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);	884	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);
877	Value* added = root->appendNew<Value>(proc, Add, Origin(), multiplied, arg2);	885	Value* added = root->appendNew<Value>(proc, Add, Origin(), multiplied, arg2);
878	root->appendNew<ControlValue>(proc, Return, Origin(), added);	886	root->appendNewControlValue(proc, Return, Origin(), added);
879		887
880	auto code = compile(proc);	888	auto code = compile(proc);
881		889
Lines 899-905 void testMulAddArgsRight() Source/JavaScriptCore/b3/testb3.cpp_sec47
899	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);	907	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
900	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg1, arg2);	908	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg1, arg2);
901	Value* added = root->appendNew<Value>(proc, Add, Origin(), arg0, multiplied);	909	Value* added = root->appendNew<Value>(proc, Add, Origin(), arg0, multiplied);
902	root->appendNew<ControlValue>(proc, Return, Origin(), added);	910	root->appendNewControlValue(proc, Return, Origin(), added);
903		911
904	auto code = compile(proc);	912	auto code = compile(proc);
905		913
Lines 926-932 void testMulAddArgsLeft32() Source/JavaScriptCore/b3/testb3.cpp_sec48
926	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));	934	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));
927	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);	935	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);
928	Value* added = root->appendNew<Value>(proc, Add, Origin(), multiplied, arg2);	936	Value* added = root->appendNew<Value>(proc, Add, Origin(), multiplied, arg2);
929	root->appendNew<ControlValue>(proc, Return, Origin(), added);	937	root->appendNewControlValue(proc, Return, Origin(), added);
930		938
931	auto code = compile(proc);	939	auto code = compile(proc);
932		940
Lines 953-959 void testMulAddArgsRight32() Source/JavaScriptCore/b3/testb3.cpp_sec49
953	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));	961	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));
954	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg1, arg2);	962	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg1, arg2);
955	Value* added = root->appendNew<Value>(proc, Add, Origin(), arg0, multiplied);	963	Value* added = root->appendNew<Value>(proc, Add, Origin(), arg0, multiplied);
956	root->appendNew<ControlValue>(proc, Return, Origin(), added);	964	root->appendNewControlValue(proc, Return, Origin(), added);
957		965
958	auto code = compile(proc);	966	auto code = compile(proc);
959		967
Lines 977-983 void testMulSubArgsLeft() Source/JavaScriptCore/b3/testb3.cpp_sec50
977	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);	985	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
978	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);	986	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);
979	Value* added = root->appendNew<Value>(proc, Sub, Origin(), multiplied, arg2);	987	Value* added = root->appendNew<Value>(proc, Sub, Origin(), multiplied, arg2);
980	root->appendNew<ControlValue>(proc, Return, Origin(), added);	988	root->appendNewControlValue(proc, Return, Origin(), added);
981		989
982	auto code = compile(proc);	990	auto code = compile(proc);
983		991
Lines 1001-1007 void testMulSubArgsRight() Source/JavaScriptCore/b3/testb3.cpp_sec51
1001	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);	1009	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
1002	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg1, arg2);	1010	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg1, arg2);
1003	Value* added = root->appendNew<Value>(proc, Sub, Origin(), arg0, multiplied);	1011	Value* added = root->appendNew<Value>(proc, Sub, Origin(), arg0, multiplied);
1004	root->appendNew<ControlValue>(proc, Return, Origin(), added);	1012	root->appendNewControlValue(proc, Return, Origin(), added);
1005		1013
1006	auto code = compile(proc);	1014	auto code = compile(proc);
1007		1015
Lines 1028-1034 void testMulSubArgsLeft32() Source/JavaScriptCore/b3/testb3.cpp_sec52
1028	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));	1036	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));
1029	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);	1037	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);
1030	Value* added = root->appendNew<Value>(proc, Sub, Origin(), multiplied, arg2);	1038	Value* added = root->appendNew<Value>(proc, Sub, Origin(), multiplied, arg2);
1031	root->appendNew<ControlValue>(proc, Return, Origin(), added);	1039	root->appendNewControlValue(proc, Return, Origin(), added);
1032		1040
1033	auto code = compile(proc);	1041	auto code = compile(proc);
1034		1042
Lines 1055-1061 void testMulSubArgsRight32() Source/JavaScriptCore/b3/testb3.cpp_sec53
1055	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));	1063	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));
1056	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg1, arg2);	1064	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg1, arg2);
1057	Value* added = root->appendNew<Value>(proc, Sub, Origin(), arg0, multiplied);	1065	Value* added = root->appendNew<Value>(proc, Sub, Origin(), arg0, multiplied);
1058	root->appendNew<ControlValue>(proc, Return, Origin(), added);	1066	root->appendNewControlValue(proc, Return, Origin(), added);
1059		1067
1060	auto code = compile(proc);	1068	auto code = compile(proc);
1061		1069
Lines 1079-1085 void testMulNegArgs() Source/JavaScriptCore/b3/testb3.cpp_sec54
1079	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);	1087	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);
1080	Value* zero = root->appendNew<Const64Value>(proc, Origin(), 0);	1088	Value* zero = root->appendNew<Const64Value>(proc, Origin(), 0);
1081	Value* added = root->appendNew<Value>(proc, Sub, Origin(), zero, multiplied);	1089	Value* added = root->appendNew<Value>(proc, Sub, Origin(), zero, multiplied);
1082	root->appendNew<ControlValue>(proc, Return, Origin(), added);	1090	root->appendNewControlValue(proc, Return, Origin(), added);
1083		1091
1084	auto code = compile(proc);	1092	auto code = compile(proc);
1085		1093
Lines 1103-1109 void testMulNegArgs32() Source/JavaScriptCore/b3/testb3.cpp_sec55
1103	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);	1111	Value* multiplied = root->appendNew<Value>(proc, Mul, Origin(), arg0, arg1);
1104	Value* zero = root->appendNew<Const32Value>(proc, Origin(), 0);	1112	Value* zero = root->appendNew<Const32Value>(proc, Origin(), 0);
1105	Value* added = root->appendNew<Value>(proc, Sub, Origin(), zero, multiplied);	1113	Value* added = root->appendNew<Value>(proc, Sub, Origin(), zero, multiplied);
1106	root->appendNew<ControlValue>(proc, Return, Origin(), added);	1114	root->appendNewControlValue(proc, Return, Origin(), added);
1107		1115
1108	auto code = compile(proc);	1116	auto code = compile(proc);
1109		1117
Lines 1120-1126 void testMulArgDouble(double a) Source/JavaScriptCore/b3/testb3.cpp_sec56
1120	Procedure proc;	1128	Procedure proc;
1121	BasicBlock* root = proc.addBlock();	1129	BasicBlock* root = proc.addBlock();
1122	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1130	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1123	root->appendNew<ControlValue>(	1131	root->appendNewControlValue(
1124	proc, Return, Origin(),	1132	proc, Return, Origin(),
1125	root->appendNew<Value>(proc, Mul, Origin(), value, value));	1133	root->appendNew<Value>(proc, Mul, Origin(), value, value));
1126		1134
Lines 1133-1139 void testMulArgsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec57
1133	BasicBlock* root = proc.addBlock();	1141	BasicBlock* root = proc.addBlock();
1134	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1142	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1135	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);	1143	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
1136	root->appendNew<ControlValue>(	1144	root->appendNewControlValue(
1137	proc, Return, Origin(),	1145	proc, Return, Origin(),
1138	root->appendNew<Value>(proc, Mul, Origin(), valueA, valueB));	1146	root->appendNew<Value>(proc, Mul, Origin(), valueA, valueB));
1139		1147
Lines 1146-1152 void testMulArgImmDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec58
1146	BasicBlock* root = proc.addBlock();	1154	BasicBlock* root = proc.addBlock();
1147	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1155	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1148	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	1156	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
1149	root->appendNew<ControlValue>(	1157	root->appendNewControlValue(
1150	proc, Return, Origin(),	1158	proc, Return, Origin(),
1151	root->appendNew<Value>(proc, Mul, Origin(), valueA, valueB));	1159	root->appendNew<Value>(proc, Mul, Origin(), valueA, valueB));
1152		1160
Lines 1159-1165 void testMulImmArgDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec59
1159	BasicBlock* root = proc.addBlock();	1167	BasicBlock* root = proc.addBlock();
1160	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	1168	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
1161	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1169	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1162	root->appendNew<ControlValue>(	1170	root->appendNewControlValue(
1163	proc, Return, Origin(),	1171	proc, Return, Origin(),
1164	root->appendNew<Value>(proc, Mul, Origin(), valueA, valueB));	1172	root->appendNew<Value>(proc, Mul, Origin(), valueA, valueB));
1165		1173
Lines 1172-1178 void testMulImmsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec60
1172	BasicBlock* root = proc.addBlock();	1180	BasicBlock* root = proc.addBlock();
1173	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	1181	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
1174	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	1182	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
1175	root->appendNew<ControlValue>(	1183	root->appendNewControlValue(
1176	proc, Return, Origin(),	1184	proc, Return, Origin(),
1177	root->appendNew<Value>(proc, Mul, Origin(), valueA, valueB));	1185	root->appendNew<Value>(proc, Mul, Origin(), valueA, valueB));
1178		1186
Lines 1188-1194 void testMulArgFloat(float a) Source/JavaScriptCore/b3/testb3.cpp_sec61
1188	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	1196	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
1189	Value* result = root->appendNew<Value>(proc, Mul, Origin(), floatValue, floatValue);	1197	Value* result = root->appendNew<Value>(proc, Mul, Origin(), floatValue, floatValue);
1190	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1198	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1191	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1199	root->appendNewControlValue(proc, Return, Origin(), result32);
1192		1200
1193		1201
1194	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a * a)));	1202	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a * a)));
Lines 1206-1212 void testMulArgsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec62
1206	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);	1214	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);
1207	Value* result = root->appendNew<Value>(proc, Mul, Origin(), floatValue1, floatValue2);	1215	Value* result = root->appendNew<Value>(proc, Mul, Origin(), floatValue1, floatValue2);
1208	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1216	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1209	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1217	root->appendNewControlValue(proc, Return, Origin(), result32);
1210		1218
1211	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a * b)));	1219	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a * b)));
1212	}	1220	}
Lines 1221-1227 void testMulArgImmFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec63
1221	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);	1229	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);
1222	Value* result = root->appendNew<Value>(proc, Mul, Origin(), floatValue, constValue);	1230	Value* result = root->appendNew<Value>(proc, Mul, Origin(), floatValue, constValue);
1223	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1231	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1224	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1232	root->appendNewControlValue(proc, Return, Origin(), result32);
1225		1233
1226	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a * b)));	1234	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a * b)));
1227	}	1235	}
Lines 1236-1242 void testMulImmArgFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec64
1236	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);	1244	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);
1237	Value* result = root->appendNew<Value>(proc, Mul, Origin(), constValue, floatValue);	1245	Value* result = root->appendNew<Value>(proc, Mul, Origin(), constValue, floatValue);
1238	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1246	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1239	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1247	root->appendNewControlValue(proc, Return, Origin(), result32);
1240		1248
1241	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a * b)));	1249	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a * b)));
1242	}	1250	}
Lines 1249-1255 void testMulImmsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec65
1249	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);	1257	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);
1250	Value* result = root->appendNew<Value>(proc, Mul, Origin(), constValue1, constValue2);	1258	Value* result = root->appendNew<Value>(proc, Mul, Origin(), constValue1, constValue2);
1251	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1259	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1252	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1260	root->appendNewControlValue(proc, Return, Origin(), result32);
1253		1261
1254	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(a * b)));	1262	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(a * b)));
1255	}	1263	}
Lines 1265-1271 void testMulArgFloatWithUselessDoubleCon Source/JavaScriptCore/b3/testb3.cpp_sec66
1265	Value* result = root->appendNew<Value>(proc, Mul, Origin(), asDouble, asDouble);	1273	Value* result = root->appendNew<Value>(proc, Mul, Origin(), asDouble, asDouble);
1266	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	1274	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
1267	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	1275	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
1268	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1276	root->appendNewControlValue(proc, Return, Origin(), result32);
1269		1277
1270	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a * a)));	1278	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a * a)));
1271	}	1279	}
Lines 1285-1291 void testMulArgsFloatWithUselessDoubleCo Source/JavaScriptCore/b3/testb3.cpp_sec67
1285	Value* result = root->appendNew<Value>(proc, Mul, Origin(), asDouble1, asDouble2);	1293	Value* result = root->appendNew<Value>(proc, Mul, Origin(), asDouble1, asDouble2);
1286	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	1294	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
1287	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	1295	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
1288	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1296	root->appendNewControlValue(proc, Return, Origin(), result32);
1289		1297
1290	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a * b)));	1298	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a * b)));
1291	}	1299	}
Lines 1307-1313 void testMulArgsFloatWithEffectfulDouble Source/JavaScriptCore/b3/testb3.cpp_sec68
1307	Value* doubleMulress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);	1315	Value* doubleMulress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
1308	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleMulress);	1316	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleMulress);
1309	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	1317	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
1310	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1318	root->appendNewControlValue(proc, Return, Origin(), result32);
1311		1319
1312	double effect = 0;	1320	double effect = 0;
1313	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b), &effect), bitwise_cast<int32_t>(a * b)));	1321	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b), &effect), bitwise_cast<int32_t>(a * b)));
Lines 1319-1325 void testDivArgDouble(double a) Source/JavaScriptCore/b3/testb3.cpp_sec69
1319	Procedure proc;	1327	Procedure proc;
1320	BasicBlock* root = proc.addBlock();	1328	BasicBlock* root = proc.addBlock();
1321	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1329	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1322	root->appendNew<ControlValue>(	1330	root->appendNewControlValue(
1323	proc, Return, Origin(),	1331	proc, Return, Origin(),
1324	root->appendNew<Value>(proc, Div, Origin(), value, value));	1332	root->appendNew<Value>(proc, Div, Origin(), value, value));
1325		1333
Lines 1332-1338 void testDivArgsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec70
1332	BasicBlock* root = proc.addBlock();	1340	BasicBlock* root = proc.addBlock();
1333	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1341	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1334	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);	1342	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
1335	root->appendNew<ControlValue>(	1343	root->appendNewControlValue(
1336	proc, Return, Origin(),	1344	proc, Return, Origin(),
1337	root->appendNew<Value>(proc, Div, Origin(), valueA, valueB));	1345	root->appendNew<Value>(proc, Div, Origin(), valueA, valueB));
1338		1346
Lines 1345-1351 void testDivArgImmDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec71
1345	BasicBlock* root = proc.addBlock();	1353	BasicBlock* root = proc.addBlock();
1346	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1354	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1347	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	1355	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
1348	root->appendNew<ControlValue>(	1356	root->appendNewControlValue(
1349	proc, Return, Origin(),	1357	proc, Return, Origin(),
1350	root->appendNew<Value>(proc, Div, Origin(), valueA, valueB));	1358	root->appendNew<Value>(proc, Div, Origin(), valueA, valueB));
1351		1359
Lines 1358-1364 void testDivImmArgDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec72
1358	BasicBlock* root = proc.addBlock();	1366	BasicBlock* root = proc.addBlock();
1359	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	1367	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
1360	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1368	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1361	root->appendNew<ControlValue>(	1369	root->appendNewControlValue(
1362	proc, Return, Origin(),	1370	proc, Return, Origin(),
1363	root->appendNew<Value>(proc, Div, Origin(), valueA, valueB));	1371	root->appendNew<Value>(proc, Div, Origin(), valueA, valueB));
1364		1372
Lines 1371-1377 void testDivImmsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec73
1371	BasicBlock* root = proc.addBlock();	1379	BasicBlock* root = proc.addBlock();
1372	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	1380	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
1373	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	1381	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
1374	root->appendNew<ControlValue>(	1382	root->appendNewControlValue(
1375	proc, Return, Origin(),	1383	proc, Return, Origin(),
1376	root->appendNew<Value>(proc, Div, Origin(), valueA, valueB));	1384	root->appendNew<Value>(proc, Div, Origin(), valueA, valueB));
1377		1385
Lines 1387-1393 void testDivArgFloat(float a) Source/JavaScriptCore/b3/testb3.cpp_sec74
1387	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	1395	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
1388	Value* result = root->appendNew<Value>(proc, Div, Origin(), floatValue, floatValue);	1396	Value* result = root->appendNew<Value>(proc, Div, Origin(), floatValue, floatValue);
1389	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1397	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1390	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1398	root->appendNewControlValue(proc, Return, Origin(), result32);
1391		1399
1392		1400
1393	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a / a)));	1401	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a / a)));
Lines 1405-1411 void testDivArgsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec75
1405	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);	1413	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);
1406	Value* result = root->appendNew<Value>(proc, Div, Origin(), floatValue1, floatValue2);	1414	Value* result = root->appendNew<Value>(proc, Div, Origin(), floatValue1, floatValue2);
1407	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1415	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1408	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1416	root->appendNewControlValue(proc, Return, Origin(), result32);
1409		1417
1410	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a / b)));	1418	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a / b)));
1411	}	1419	}
Lines 1420-1426 void testDivArgImmFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec76
1420	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);	1428	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);
1421	Value* result = root->appendNew<Value>(proc, Div, Origin(), floatValue, constValue);	1429	Value* result = root->appendNew<Value>(proc, Div, Origin(), floatValue, constValue);
1422	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1430	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1423	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1431	root->appendNewControlValue(proc, Return, Origin(), result32);
1424		1432
1425	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a / b)));	1433	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a / b)));
1426	}	1434	}
Lines 1435-1441 void testDivImmArgFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec77
1435	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);	1443	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);
1436	Value* result = root->appendNew<Value>(proc, Div, Origin(), constValue, floatValue);	1444	Value* result = root->appendNew<Value>(proc, Div, Origin(), constValue, floatValue);
1437	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1445	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1438	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1446	root->appendNewControlValue(proc, Return, Origin(), result32);
1439		1447
1440	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a / b)));	1448	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a / b)));
1441	}	1449	}
Lines 1448-1454 void testDivImmsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec78
1448	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);	1456	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);
1449	Value* result = root->appendNew<Value>(proc, Div, Origin(), constValue1, constValue2);	1457	Value* result = root->appendNew<Value>(proc, Div, Origin(), constValue1, constValue2);
1450	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1458	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1451	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1459	root->appendNewControlValue(proc, Return, Origin(), result32);
1452		1460
1453	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(a / b)));	1461	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(a / b)));
1454	}	1462	}
Lines 1458-1464 void testModArgDouble(double a) Source/JavaScriptCore/b3/testb3.cpp_sec79
1458	Procedure proc;	1466	Procedure proc;
1459	BasicBlock* root = proc.addBlock();	1467	BasicBlock* root = proc.addBlock();
1460	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1468	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1461	root->appendNew<ControlValue>(	1469	root->appendNewControlValue(
1462	proc, Return, Origin(),	1470	proc, Return, Origin(),
1463	root->appendNew<Value>(proc, Mod, Origin(), value, value));	1471	root->appendNew<Value>(proc, Mod, Origin(), value, value));
1464		1472
Lines 1471-1477 void testModArgsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec80
1471	BasicBlock* root = proc.addBlock();	1479	BasicBlock* root = proc.addBlock();
1472	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1480	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1473	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);	1481	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
1474	root->appendNew<ControlValue>(	1482	root->appendNewControlValue(
1475	proc, Return, Origin(),	1483	proc, Return, Origin(),
1476	root->appendNew<Value>(proc, Mod, Origin(), valueA, valueB));	1484	root->appendNew<Value>(proc, Mod, Origin(), valueA, valueB));
1477		1485
Lines 1484-1490 void testModArgImmDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec81
1484	BasicBlock* root = proc.addBlock();	1492	BasicBlock* root = proc.addBlock();
1485	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1493	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1486	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	1494	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
1487	root->appendNew<ControlValue>(	1495	root->appendNewControlValue(
1488	proc, Return, Origin(),	1496	proc, Return, Origin(),
1489	root->appendNew<Value>(proc, Mod, Origin(), valueA, valueB));	1497	root->appendNew<Value>(proc, Mod, Origin(), valueA, valueB));
1490		1498
Lines 1497-1503 void testModImmArgDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec82
1497	BasicBlock* root = proc.addBlock();	1505	BasicBlock* root = proc.addBlock();
1498	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	1506	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
1499	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1507	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1500	root->appendNew<ControlValue>(	1508	root->appendNewControlValue(
1501	proc, Return, Origin(),	1509	proc, Return, Origin(),
1502	root->appendNew<Value>(proc, Mod, Origin(), valueA, valueB));	1510	root->appendNew<Value>(proc, Mod, Origin(), valueA, valueB));
1503		1511
Lines 1510-1516 void testModImmsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec83
1510	BasicBlock* root = proc.addBlock();	1518	BasicBlock* root = proc.addBlock();
1511	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	1519	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
1512	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	1520	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
1513	root->appendNew<ControlValue>(	1521	root->appendNewControlValue(
1514	proc, Return, Origin(),	1522	proc, Return, Origin(),
1515	root->appendNew<Value>(proc, Mod, Origin(), valueA, valueB));	1523	root->appendNew<Value>(proc, Mod, Origin(), valueA, valueB));
1516		1524
Lines 1526-1532 void testModArgFloat(float a) Source/JavaScriptCore/b3/testb3.cpp_sec84
1526	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	1534	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
1527	Value* result = root->appendNew<Value>(proc, Mod, Origin(), floatValue, floatValue);	1535	Value* result = root->appendNew<Value>(proc, Mod, Origin(), floatValue, floatValue);
1528	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1536	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1529	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1537	root->appendNewControlValue(proc, Return, Origin(), result32);
1530		1538
1531		1539
1532	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fmod(a, a)))));	1540	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fmod(a, a)))));
Lines 1544-1550 void testModArgsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec85
1544	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);	1552	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);
1545	Value* result = root->appendNew<Value>(proc, Mod, Origin(), floatValue1, floatValue2);	1553	Value* result = root->appendNew<Value>(proc, Mod, Origin(), floatValue1, floatValue2);
1546	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1554	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1547	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1555	root->appendNewControlValue(proc, Return, Origin(), result32);
1548		1556
1549	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(static_cast<float>(fmod(a, b)))));	1557	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(static_cast<float>(fmod(a, b)))));
1550	}	1558	}
Lines 1559-1565 void testModArgImmFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec86
1559	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);	1567	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);
1560	Value* result = root->appendNew<Value>(proc, Mod, Origin(), floatValue, constValue);	1568	Value* result = root->appendNew<Value>(proc, Mod, Origin(), floatValue, constValue);
1561	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1569	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1562	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1570	root->appendNewControlValue(proc, Return, Origin(), result32);
1563		1571
1564	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fmod(a, b)))));	1572	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fmod(a, b)))));
1565	}	1573	}
Lines 1574-1580 void testModImmArgFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec87
1574	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);	1582	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);
1575	Value* result = root->appendNew<Value>(proc, Mod, Origin(), constValue, floatValue);	1583	Value* result = root->appendNew<Value>(proc, Mod, Origin(), constValue, floatValue);
1576	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1584	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1577	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1585	root->appendNewControlValue(proc, Return, Origin(), result32);
1578		1586
1579	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(static_cast<float>(fmod(a, b)))));	1587	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(static_cast<float>(fmod(a, b)))));
1580	}	1588	}
Lines 1587-1593 void testModImmsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec88
1587	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);	1595	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);
1588	Value* result = root->appendNew<Value>(proc, Mod, Origin(), constValue1, constValue2);	1596	Value* result = root->appendNew<Value>(proc, Mod, Origin(), constValue1, constValue2);
1589	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	1597	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1590	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1598	root->appendNewControlValue(proc, Return, Origin(), result32);
1591		1599
1592	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(static_cast<float>(fmod(a, b)))));	1600	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(static_cast<float>(fmod(a, b)))));
1593	}	1601	}
Lines 1603-1609 void testDivArgFloatWithUselessDoubleCon Source/JavaScriptCore/b3/testb3.cpp_sec89
1603	Value* result = root->appendNew<Value>(proc, Div, Origin(), asDouble, asDouble);	1611	Value* result = root->appendNew<Value>(proc, Div, Origin(), asDouble, asDouble);
1604	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	1612	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
1605	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	1613	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
1606	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1614	root->appendNewControlValue(proc, Return, Origin(), result32);
1607		1615
1608	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a / a)));	1616	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a / a)));
1609	}	1617	}
Lines 1623-1629 void testDivArgsFloatWithUselessDoubleCo Source/JavaScriptCore/b3/testb3.cpp_sec90
1623	Value* result = root->appendNew<Value>(proc, Div, Origin(), asDouble1, asDouble2);	1631	Value* result = root->appendNew<Value>(proc, Div, Origin(), asDouble1, asDouble2);
1624	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	1632	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
1625	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	1633	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
1626	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1634	root->appendNewControlValue(proc, Return, Origin(), result32);
1627		1635
1628	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a / b)));	1636	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a / b)));
1629	}	1637	}
Lines 1645-1651 void testDivArgsFloatWithEffectfulDouble Source/JavaScriptCore/b3/testb3.cpp_sec91
1645	Value* doubleDivress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);	1653	Value* doubleDivress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
1646	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleDivress);	1654	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleDivress);
1647	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	1655	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
1648	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	1656	root->appendNewControlValue(proc, Return, Origin(), result32);
1649		1657
1650	double effect = 0;	1658	double effect = 0;
1651	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b), &effect), bitwise_cast<int32_t>(a / b)));	1659	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b), &effect), bitwise_cast<int32_t>(a / b)));
Lines 1657-1663 void testSubArg(int a) Source/JavaScriptCore/b3/testb3.cpp_sec92
1657	Procedure proc;	1665	Procedure proc;
1658	BasicBlock* root = proc.addBlock();	1666	BasicBlock* root = proc.addBlock();
1659	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	1667	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
1660	root->appendNew<ControlValue>(	1668	root->appendNewControlValue(
1661	proc, Return, Origin(),	1669	proc, Return, Origin(),
1662	root->appendNew<Value>(proc, Sub, Origin(), value, value));	1670	root->appendNew<Value>(proc, Sub, Origin(), value, value));
1663		1671
Lines 1668-1674 void testSubArgs(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec93
1668	{	1676	{
1669	Procedure proc;	1677	Procedure proc;
1670	BasicBlock* root = proc.addBlock();	1678	BasicBlock* root = proc.addBlock();
1671	root->appendNew<ControlValue>(	1679	root->appendNewControlValue(
1672	proc, Return, Origin(),	1680	proc, Return, Origin(),
1673	root->appendNew<Value>(	1681	root->appendNew<Value>(
1674	proc, Sub, Origin(),	1682	proc, Sub, Origin(),
Lines 1682-1688 void testSubArgImm(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec94
1682	{	1690	{
1683	Procedure proc;	1691	Procedure proc;
1684	BasicBlock* root = proc.addBlock();	1692	BasicBlock* root = proc.addBlock();
1685	root->appendNew<ControlValue>(	1693	root->appendNewControlValue(
1686	proc, Return, Origin(),	1694	proc, Return, Origin(),
1687	root->appendNew<Value>(	1695	root->appendNew<Value>(
1688	proc, Sub, Origin(),	1696	proc, Sub, Origin(),
Lines 1703-1709 void testNegValueSubOne(int a) Source/JavaScriptCore/b3/testb3.cpp_sec95
1703	Value* negArgumentMinusOne = root->appendNew<Value>(proc, Sub, Origin(),	1711	Value* negArgumentMinusOne = root->appendNew<Value>(proc, Sub, Origin(),
1704	negArgument,	1712	negArgument,
1705	root->appendNew<Const64Value>(proc, Origin(), 1));	1713	root->appendNew<Const64Value>(proc, Origin(), 1));
1706	root->appendNew<ControlValue>(proc, Return, Origin(), negArgumentMinusOne);	1714	root->appendNewControlValue(proc, Return, Origin(), negArgumentMinusOne);
1707	CHECK(compileAndRun<int>(proc, a) == -a - 1);	1715	CHECK(compileAndRun<int>(proc, a) == -a - 1);
1708	}	1716	}
1709		1717
Lines 1711-1717 void testSubImmArg(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec96
1711	{	1719	{
1712	Procedure proc;	1720	Procedure proc;
1713	BasicBlock* root = proc.addBlock();	1721	BasicBlock* root = proc.addBlock();
1714	root->appendNew<ControlValue>(	1722	root->appendNewControlValue(
1715	proc, Return, Origin(),	1723	proc, Return, Origin(),
1716	root->appendNew<Value>(	1724	root->appendNew<Value>(
1717	proc, Sub, Origin(),	1725	proc, Sub, Origin(),
Lines 1730-1736 void testSubArgMem(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec97
1730	Value* result = root->appendNew<Value>(proc, Sub, Origin(),	1738	Value* result = root->appendNew<Value>(proc, Sub, Origin(),
1731	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	1739	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
1732	load);	1740	load);
1733	root->appendNew<ControlValue>(proc, Return, Origin(), result);	1741	root->appendNewControlValue(proc, Return, Origin(), result);
1734		1742
1735	CHECK(compileAndRun<int64_t>(proc, a, &b) == a - b);	1743	CHECK(compileAndRun<int64_t>(proc, a, &b) == a - b);
1736	}	1744	}
Lines 1745-1751 void testSubMemArg(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec98
1745	load,	1753	load,
1746	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	1754	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
1747	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	1755	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
1748	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	1756	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
1749		1757
1750	int64_t inputOutput = a;	1758	int64_t inputOutput = a;
1751	CHECK(!compileAndRun<int64_t>(proc, &inputOutput, b));	1759	CHECK(!compileAndRun<int64_t>(proc, &inputOutput, b));
Lines 1762-1768 void testSubImmMem(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec99
1762	root->appendNew<Const64Value>(proc, Origin(), a),	1770	root->appendNew<Const64Value>(proc, Origin(), a),
1763	load);	1771	load);
1764	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	1772	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
1765	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	1773	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
1766		1774
1767	int64_t inputOutput = b;	1775	int64_t inputOutput = b;
1768	CHECK(!compileAndRun<int>(proc, &inputOutput));	1776	CHECK(!compileAndRun<int>(proc, &inputOutput));
Lines 1779-1785 void testSubMemImm(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec100
1779	load,	1787	load,
1780	root->appendNew<Const64Value>(proc, Origin(), b));	1788	root->appendNew<Const64Value>(proc, Origin(), b));
1781	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	1789	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
1782	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	1790	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
1783		1791
1784	int64_t inputOutput = a;	1792	int64_t inputOutput = a;
1785	CHECK(!compileAndRun<int>(proc, &inputOutput));	1793	CHECK(!compileAndRun<int>(proc, &inputOutput));
Lines 1791-1797 void testSubArgs32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec101
1791	{	1799	{
1792	Procedure proc;	1800	Procedure proc;
1793	BasicBlock* root = proc.addBlock();	1801	BasicBlock* root = proc.addBlock();
1794	root->appendNew<ControlValue>(	1802	root->appendNewControlValue(
1795	proc, Return, Origin(),	1803	proc, Return, Origin(),
1796	root->appendNew<Value>(	1804	root->appendNew<Value>(
1797	proc, Sub, Origin(),	1805	proc, Sub, Origin(),
Lines 1809-1815 void testSubArgImm32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec102
1809	{	1817	{
1810	Procedure proc;	1818	Procedure proc;
1811	BasicBlock* root = proc.addBlock();	1819	BasicBlock* root = proc.addBlock();
1812	root->appendNew<ControlValue>(	1820	root->appendNewControlValue(
1813	proc, Return, Origin(),	1821	proc, Return, Origin(),
1814	root->appendNew<Value>(	1822	root->appendNew<Value>(
1815	proc, Sub, Origin(),	1823	proc, Sub, Origin(),
Lines 1825-1831 void testSubImmArg32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec103
1825	{	1833	{
1826	Procedure proc;	1834	Procedure proc;
1827	BasicBlock* root = proc.addBlock();	1835	BasicBlock* root = proc.addBlock();
1828	root->appendNew<ControlValue>(	1836	root->appendNewControlValue(
1829	proc, Return, Origin(),	1837	proc, Return, Origin(),
1830	root->appendNew<Value>(	1838	root->appendNew<Value>(
1831	proc, Sub, Origin(),	1839	proc, Sub, Origin(),
Lines 1847-1853 void testSubMemArg32(int32_t a, int32_t Source/JavaScriptCore/b3/testb3.cpp_sec104
1847	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	1855	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
1848	Value* result = root->appendNew<Value>(proc, Sub, Origin(), load, argument);	1856	Value* result = root->appendNew<Value>(proc, Sub, Origin(), load, argument);
1849	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	1857	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
1850	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	1858	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
1851		1859
1852	int32_t inputOutput = a;	1860	int32_t inputOutput = a;
1853	CHECK(!compileAndRun<int32_t>(proc, &inputOutput, b));	1861	CHECK(!compileAndRun<int32_t>(proc, &inputOutput, b));
Lines 1863-1869 void testSubArgMem32(int32_t a, int32_t Source/JavaScriptCore/b3/testb3.cpp_sec105
1863	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),	1871	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),
1864	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	1872	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
1865	Value* result = root->appendNew<Value>(proc, Sub, Origin(), argument, load);	1873	Value* result = root->appendNew<Value>(proc, Sub, Origin(), argument, load);
1866	root->appendNew<ControlValue>(proc, Return, Origin(), result);	1874	root->appendNewControlValue(proc, Return, Origin(), result);
1867		1875
1868	CHECK(compileAndRun<int32_t>(proc, a, &b) == a - b);	1876	CHECK(compileAndRun<int32_t>(proc, a, &b) == a - b);
1869	}	1877	}
Lines 1878-1884 void testSubImmMem32(int32_t a, int32_t Source/JavaScriptCore/b3/testb3.cpp_sec106
1878	root->appendNew<Const32Value>(proc, Origin(), a),	1886	root->appendNew<Const32Value>(proc, Origin(), a),
1879	load);	1887	load);
1880	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	1888	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
1881	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	1889	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
1882		1890
1883	int32_t inputOutput = b;	1891	int32_t inputOutput = b;
1884	CHECK(!compileAndRun<int>(proc, &inputOutput));	1892	CHECK(!compileAndRun<int>(proc, &inputOutput));
Lines 1895-1901 void testSubMemImm32(int32_t a, int32_t Source/JavaScriptCore/b3/testb3.cpp_sec107
1895	load,	1903	load,
1896	root->appendNew<Const32Value>(proc, Origin(), b));	1904	root->appendNew<Const32Value>(proc, Origin(), b));
1897	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);	1905	root->appendNew<MemoryValue>(proc, Store, Origin(), result, address);
1898	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	1906	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
1899		1907
1900	int32_t inputOutput = a;	1908	int32_t inputOutput = a;
1901	CHECK(!compileAndRun<int>(proc, &inputOutput));	1909	CHECK(!compileAndRun<int>(proc, &inputOutput));
Lines 1914-1920 void testNegValueSubOne32(int a) Source/JavaScriptCore/b3/testb3.cpp_sec108
1914	Value* negArgumentMinusOne = root->appendNew<Value>(proc, Sub, Origin(),	1922	Value* negArgumentMinusOne = root->appendNew<Value>(proc, Sub, Origin(),
1915	negArgument,	1923	negArgument,
1916	root->appendNew<Const32Value>(proc, Origin(), 1));	1924	root->appendNew<Const32Value>(proc, Origin(), 1));
1917	root->appendNew<ControlValue>(proc, Return, Origin(), negArgumentMinusOne);	1925	root->appendNewControlValue(proc, Return, Origin(), negArgumentMinusOne);
1918	CHECK(compileAndRun<int>(proc, a) == -a - 1);	1926	CHECK(compileAndRun<int>(proc, a) == -a - 1);
1919	}	1927	}
1920		1928
Lines 1923-1929 void testSubArgDouble(double a) Source/JavaScriptCore/b3/testb3.cpp_sec109
1923	Procedure proc;	1931	Procedure proc;
1924	BasicBlock* root = proc.addBlock();	1932	BasicBlock* root = proc.addBlock();
1925	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1933	Value* value = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1926	root->appendNew<ControlValue>(	1934	root->appendNewControlValue(
1927	proc, Return, Origin(),	1935	proc, Return, Origin(),
1928	root->appendNew<Value>(proc, Sub, Origin(), value, value));	1936	root->appendNew<Value>(proc, Sub, Origin(), value, value));
1929		1937
Lines 1936-1942 void testSubArgsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec110
1936	BasicBlock* root = proc.addBlock();	1944	BasicBlock* root = proc.addBlock();
1937	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1945	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1938	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);	1946	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
1939	root->appendNew<ControlValue>(	1947	root->appendNewControlValue(
1940	proc, Return, Origin(),	1948	proc, Return, Origin(),
1941	root->appendNew<Value>(proc, Sub, Origin(), valueA, valueB));	1949	root->appendNew<Value>(proc, Sub, Origin(), valueA, valueB));
1942		1950
Lines 1949-1955 void testSubArgImmDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec111
1949	BasicBlock* root = proc.addBlock();	1957	BasicBlock* root = proc.addBlock();
1950	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1958	Value* valueA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1951	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	1959	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
1952	root->appendNew<ControlValue>(	1960	root->appendNewControlValue(
1953	proc, Return, Origin(),	1961	proc, Return, Origin(),
1954	root->appendNew<Value>(proc, Sub, Origin(), valueA, valueB));	1962	root->appendNew<Value>(proc, Sub, Origin(), valueA, valueB));
1955		1963
Lines 1962-1968 void testSubImmArgDouble(double a, doubl Source/JavaScriptCore/b3/testb3.cpp_sec112
1962	BasicBlock* root = proc.addBlock();	1970	BasicBlock* root = proc.addBlock();
1963	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	1971	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
1964	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	1972	Value* valueB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
1965	root->appendNew<ControlValue>(	1973	root->appendNewControlValue(
1966	proc, Return, Origin(),	1974	proc, Return, Origin(),
1967	root->appendNew<Value>(proc, Sub, Origin(), valueA, valueB));	1975	root->appendNew<Value>(proc, Sub, Origin(), valueA, valueB));
1968		1976
Lines 1975-1981 void testSubImmsDouble(double a, double Source/JavaScriptCore/b3/testb3.cpp_sec113
1975	BasicBlock* root = proc.addBlock();	1983	BasicBlock* root = proc.addBlock();
1976	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	1984	Value* valueA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
1977	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	1985	Value* valueB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
1978	root->appendNew<ControlValue>(	1986	root->appendNewControlValue(
1979	proc, Return, Origin(),	1987	proc, Return, Origin(),
1980	root->appendNew<Value>(proc, Sub, Origin(), valueA, valueB));	1988	root->appendNew<Value>(proc, Sub, Origin(), valueA, valueB));
1981		1989
Lines 1991-1997 void testSubArgFloat(float a) Source/JavaScriptCore/b3/testb3.cpp_sec114
1991	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	1999	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
1992	Value* result = root->appendNew<Value>(proc, Sub, Origin(), floatValue, floatValue);	2000	Value* result = root->appendNew<Value>(proc, Sub, Origin(), floatValue, floatValue);
1993	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	2001	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
1994	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	2002	root->appendNewControlValue(proc, Return, Origin(), result32);
1995		2003
1996		2004
1997	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a - a)));	2005	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a - a)));
Lines 2009-2015 void testSubArgsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec115
2009	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);	2017	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);
2010	Value* result = root->appendNew<Value>(proc, Sub, Origin(), floatValue1, floatValue2);	2018	Value* result = root->appendNew<Value>(proc, Sub, Origin(), floatValue1, floatValue2);
2011	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	2019	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
2012	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	2020	root->appendNewControlValue(proc, Return, Origin(), result32);
2013		2021
2014	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a - b)));	2022	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a - b)));
2015	}	2023	}
Lines 2024-2030 void testSubArgImmFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec116
2024	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);	2032	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), b);
2025	Value* result = root->appendNew<Value>(proc, Sub, Origin(), floatValue, constValue);	2033	Value* result = root->appendNew<Value>(proc, Sub, Origin(), floatValue, constValue);
2026	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	2034	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
2027	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	2035	root->appendNewControlValue(proc, Return, Origin(), result32);
2028		2036
2029	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a - b)));	2037	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a - b)));
2030	}	2038	}
Lines 2039-2045 void testSubImmArgFloat(float a, float b Source/JavaScriptCore/b3/testb3.cpp_sec117
2039	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);	2047	Value* constValue = root->appendNew<ConstFloatValue>(proc, Origin(), a);
2040	Value* result = root->appendNew<Value>(proc, Sub, Origin(), constValue, floatValue);	2048	Value* result = root->appendNew<Value>(proc, Sub, Origin(), constValue, floatValue);
2041	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	2049	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
2042	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	2050	root->appendNewControlValue(proc, Return, Origin(), result32);
2043		2051
2044	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a - b)));	2052	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a - b)));
2045	}	2053	}
Lines 2052-2058 void testSubImmsFloat(float a, float b) Source/JavaScriptCore/b3/testb3.cpp_sec118
2052	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);	2060	Value* constValue2 = root->appendNew<ConstFloatValue>(proc, Origin(), b);
2053	Value* result = root->appendNew<Value>(proc, Sub, Origin(), constValue1, constValue2);	2061	Value* result = root->appendNew<Value>(proc, Sub, Origin(), constValue1, constValue2);
2054	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	2062	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
2055	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	2063	root->appendNewControlValue(proc, Return, Origin(), result32);
2056		2064
2057	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(a - b)));	2065	CHECK(isIdentical(compileAndRun<int32_t>(proc), bitwise_cast<int32_t>(a - b)));
2058	}	2066	}
Lines 2068-2074 void testSubArgFloatWithUselessDoubleCon Source/JavaScriptCore/b3/testb3.cpp_sec119
2068	Value* result = root->appendNew<Value>(proc, Sub, Origin(), asDouble, asDouble);	2076	Value* result = root->appendNew<Value>(proc, Sub, Origin(), asDouble, asDouble);
2069	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	2077	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
2070	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	2078	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
2071	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	2079	root->appendNewControlValue(proc, Return, Origin(), result32);
2072		2080
2073	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a - a)));	2081	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(a - a)));
2074	}	2082	}
Lines 2088-2094 void testSubArgsFloatWithUselessDoubleCo Source/JavaScriptCore/b3/testb3.cpp_sec120
2088	Value* result = root->appendNew<Value>(proc, Sub, Origin(), asDouble1, asDouble2);	2096	Value* result = root->appendNew<Value>(proc, Sub, Origin(), asDouble1, asDouble2);
2089	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	2097	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
2090	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	2098	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
2091	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	2099	root->appendNewControlValue(proc, Return, Origin(), result32);
2092		2100
2093	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a - b)));	2101	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitwise_cast<int32_t>(a - b)));
2094	}	2102	}
Lines 2110-2116 void testSubArgsFloatWithEffectfulDouble Source/JavaScriptCore/b3/testb3.cpp_sec121
2110	Value* doubleSubress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);	2118	Value* doubleSubress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
2111	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleSubress);	2119	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleSubress);
2112	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	2120	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
2113	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	2121	root->appendNewControlValue(proc, Return, Origin(), result32);
2114		2122
2115	double effect = 0;	2123	double effect = 0;
2116	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b), &effect), bitwise_cast<int32_t>(a - b)));	2124	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b), &effect), bitwise_cast<int32_t>(a - b)));
Lines 2121-2127 void testBitAndArgs(int64_t a, int64_t b Source/JavaScriptCore/b3/testb3.cpp_sec122
2121	{	2129	{
2122	Procedure proc;	2130	Procedure proc;
2123	BasicBlock* root = proc.addBlock();	2131	BasicBlock* root = proc.addBlock();
2124	root->appendNew<ControlValue>(	2132	root->appendNewControlValue(
2125	proc, Return, Origin(),	2133	proc, Return, Origin(),
2126	root->appendNew<Value>(	2134	root->appendNew<Value>(
2127	proc, BitAnd, Origin(),	2135	proc, BitAnd, Origin(),
Lines 2136-2142 void testBitAndSameArg(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec123
2136	Procedure proc;	2144	Procedure proc;
2137	BasicBlock* root = proc.addBlock();	2145	BasicBlock* root = proc.addBlock();
2138	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	2146	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
2139	root->appendNew<ControlValue>(	2147	root->appendNewControlValue(
2140	proc, Return, Origin(),	2148	proc, Return, Origin(),
2141	root->appendNew<Value>(	2149	root->appendNew<Value>(
2142	proc, BitAnd, Origin(),	2150	proc, BitAnd, Origin(),
Lines 2150-2156 void testBitAndImms(int64_t a, int64_t b Source/JavaScriptCore/b3/testb3.cpp_sec124
2150	{	2158	{
2151	Procedure proc;	2159	Procedure proc;
2152	BasicBlock* root = proc.addBlock();	2160	BasicBlock* root = proc.addBlock();
2153	root->appendNew<ControlValue>(	2161	root->appendNewControlValue(
2154	proc, Return, Origin(),	2162	proc, Return, Origin(),
2155	root->appendNew<Value>(	2163	root->appendNew<Value>(
2156	proc, BitAnd, Origin(),	2164	proc, BitAnd, Origin(),
Lines 2164-2170 void testBitAndArgImm(int64_t a, int64_t Source/JavaScriptCore/b3/testb3.cpp_sec125
2164	{	2172	{
2165	Procedure proc;	2173	Procedure proc;
2166	BasicBlock* root = proc.addBlock();	2174	BasicBlock* root = proc.addBlock();
2167	root->appendNew<ControlValue>(	2175	root->appendNewControlValue(
2168	proc, Return, Origin(),	2176	proc, Return, Origin(),
2169	root->appendNew<Value>(	2177	root->appendNew<Value>(
2170	proc, BitAnd, Origin(),	2178	proc, BitAnd, Origin(),
Lines 2178-2184 void testBitAndImmArg(int64_t a, int64_t Source/JavaScriptCore/b3/testb3.cpp_sec126
2178	{	2186	{
2179	Procedure proc;	2187	Procedure proc;
2180	BasicBlock* root = proc.addBlock();	2188	BasicBlock* root = proc.addBlock();
2181	root->appendNew<ControlValue>(	2189	root->appendNewControlValue(
2182	proc, Return, Origin(),	2190	proc, Return, Origin(),
2183	root->appendNew<Value>(	2191	root->appendNew<Value>(
2184	proc, BitAnd, Origin(),	2192	proc, BitAnd, Origin(),
Lines 2196-2202 void testBitAndBitAndArgImmImm(int64_t a Source/JavaScriptCore/b3/testb3.cpp_sec127
2196	proc, BitAnd, Origin(),	2204	proc, BitAnd, Origin(),
2197	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	2205	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
2198	root->appendNew<Const64Value>(proc, Origin(), b));	2206	root->appendNew<Const64Value>(proc, Origin(), b));
2199	root->appendNew<ControlValue>(	2207	root->appendNewControlValue(
2200	proc, Return, Origin(),	2208	proc, Return, Origin(),
2201	root->appendNew<Value>(	2209	root->appendNew<Value>(
2202	proc, BitAnd, Origin(),	2210	proc, BitAnd, Origin(),
Lines 2214-2220 void testBitAndImmBitAndArgImm(int64_t a Source/JavaScriptCore/b3/testb3.cpp_sec128
2214	proc, BitAnd, Origin(),	2222	proc, BitAnd, Origin(),
2215	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	2223	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
2216	root->appendNew<Const64Value>(proc, Origin(), c));	2224	root->appendNew<Const64Value>(proc, Origin(), c));
2217	root->appendNew<ControlValue>(	2225	root->appendNewControlValue(
2218	proc, Return, Origin(),	2226	proc, Return, Origin(),
2219	root->appendNew<Value>(	2227	root->appendNew<Value>(
2220	proc, BitAnd, Origin(),	2228	proc, BitAnd, Origin(),
Lines 2228-2234 void testBitAndArgs32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec129
2228	{	2236	{
2229	Procedure proc;	2237	Procedure proc;
2230	BasicBlock* root = proc.addBlock();	2238	BasicBlock* root = proc.addBlock();
2231	root->appendNew<ControlValue>(	2239	root->appendNewControlValue(
2232	proc, Return, Origin(),	2240	proc, Return, Origin(),
2233	root->appendNew<Value>(	2241	root->appendNew<Value>(
2234	proc, BitAnd, Origin(),	2242	proc, BitAnd, Origin(),
Lines 2248-2254 void testBitAndSameArg32(int a) Source/JavaScriptCore/b3/testb3.cpp_sec130
2248	BasicBlock* root = proc.addBlock();	2256	BasicBlock* root = proc.addBlock();
2249	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),	2257	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),
2250	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	2258	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
2251	root->appendNew<ControlValue>(	2259	root->appendNewControlValue(
2252	proc, Return, Origin(),	2260	proc, Return, Origin(),
2253	root->appendNew<Value>(	2261	root->appendNew<Value>(
2254	proc, BitAnd, Origin(),	2262	proc, BitAnd, Origin(),
Lines 2262-2268 void testBitAndImms32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec131
2262	{	2270	{
2263	Procedure proc;	2271	Procedure proc;
2264	BasicBlock* root = proc.addBlock();	2272	BasicBlock* root = proc.addBlock();
2265	root->appendNew<ControlValue>(	2273	root->appendNewControlValue(
2266	proc, Return, Origin(),	2274	proc, Return, Origin(),
2267	root->appendNew<Value>(	2275	root->appendNew<Value>(
2268	proc, BitAnd, Origin(),	2276	proc, BitAnd, Origin(),
Lines 2276-2282 void testBitAndArgImm32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec132
2276	{	2284	{
2277	Procedure proc;	2285	Procedure proc;
2278	BasicBlock* root = proc.addBlock();	2286	BasicBlock* root = proc.addBlock();
2279	root->appendNew<ControlValue>(	2287	root->appendNewControlValue(
2280	proc, Return, Origin(),	2288	proc, Return, Origin(),
2281	root->appendNew<Value>(	2289	root->appendNew<Value>(
2282	proc, BitAnd, Origin(),	2290	proc, BitAnd, Origin(),
Lines 2292-2298 void testBitAndImmArg32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec133
2292	{	2300	{
2293	Procedure proc;	2301	Procedure proc;
2294	BasicBlock* root = proc.addBlock();	2302	BasicBlock* root = proc.addBlock();
2295	root->appendNew<ControlValue>(	2303	root->appendNewControlValue(
2296	proc, Return, Origin(),	2304	proc, Return, Origin(),
2297	root->appendNew<Value>(	2305	root->appendNew<Value>(
2298	proc, BitAnd, Origin(),	2306	proc, BitAnd, Origin(),
Lines 2314-2320 void testBitAndBitAndArgImmImm32(int a, Source/JavaScriptCore/b3/testb3.cpp_sec134
2314	proc, Trunc, Origin(),	2322	proc, Trunc, Origin(),
2315	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	2323	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
2316	root->appendNew<Const32Value>(proc, Origin(), b));	2324	root->appendNew<Const32Value>(proc, Origin(), b));
2317	root->appendNew<ControlValue>(	2325	root->appendNewControlValue(
2318	proc, Return, Origin(),	2326	proc, Return, Origin(),
2319	root->appendNew<Value>(	2327	root->appendNew<Value>(
2320	proc, BitAnd, Origin(),	2328	proc, BitAnd, Origin(),
Lines 2334-2340 void testBitAndImmBitAndArgImm32(int a, Source/JavaScriptCore/b3/testb3.cpp_sec135
2334	proc, Trunc, Origin(),	2342	proc, Trunc, Origin(),
2335	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	2343	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
2336	root->appendNew<Const32Value>(proc, Origin(), c));	2344	root->appendNew<Const32Value>(proc, Origin(), c));
2337	root->appendNew<ControlValue>(	2345	root->appendNewControlValue(
2338	proc, Return, Origin(),	2346	proc, Return, Origin(),
2339	root->appendNew<Value>(	2347	root->appendNew<Value>(
2340	proc, BitAnd, Origin(),	2348	proc, BitAnd, Origin(),
Lines 2361-2367 void testBitAndWithMaskReturnsBooleans(i Source/JavaScriptCore/b3/testb3.cpp_sec136
2361	root->appendNew<Const64Value>(proc, Origin(), 42),	2369	root->appendNew<Const64Value>(proc, Origin(), 42),
2362	root->appendNew<Const64Value>(proc, Origin(), -5));	2370	root->appendNew<Const64Value>(proc, Origin(), -5));
2363		2371
2364	root->appendNew<ControlValue>(proc, Return, Origin(), select);	2372	root->appendNewControlValue(proc, Return, Origin(), select);
2365		2373
2366	int64_t expected = (a == b) ? -5 : 42;	2374	int64_t expected = (a == b) ? -5 : 42;
2367	CHECK(compileAndRun<int64_t>(proc, a, b) == expected);	2375	CHECK(compileAndRun<int64_t>(proc, a, b) == expected);
Lines 2378-2384 void testBitAndArgDouble(double a) Source/JavaScriptCore/b3/testb3.cpp_sec137
2378	BasicBlock* root = proc.addBlock();	2386	BasicBlock* root = proc.addBlock();
2379	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	2387	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
2380	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argument, argument);	2388	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argument, argument);
2381	root->appendNew<ControlValue>(proc, Return, Origin(), result);	2389	root->appendNewControlValue(proc, Return, Origin(), result);
2382		2390
2383	CHECK(isIdentical(compileAndRun<double>(proc, a), bitAndDouble(a, a)));	2391	CHECK(isIdentical(compileAndRun<double>(proc, a), bitAndDouble(a, a)));
2384	}	2392	}
Lines 2390-2396 void testBitAndArgsDouble(double a, doub Source/JavaScriptCore/b3/testb3.cpp_sec138
2390	Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	2398	Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
2391	Value* argumentB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);	2399	Value* argumentB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
2392	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);	2400	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);
2393	root->appendNew<ControlValue>(proc, Return, Origin(), result);	2401	root->appendNewControlValue(proc, Return, Origin(), result);
2394		2402
2395	CHECK(isIdentical(compileAndRun<double>(proc, a, b), bitAndDouble(a, b)));	2403	CHECK(isIdentical(compileAndRun<double>(proc, a, b), bitAndDouble(a, b)));
2396	}	2404	}
Lines 2402-2408 void testBitAndArgImmDouble(double a, do Source/JavaScriptCore/b3/testb3.cpp_sec139
2402	Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	2410	Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
2403	Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	2411	Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
2404	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);	2412	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);
2405	root->appendNew<ControlValue>(proc, Return, Origin(), result);	2413	root->appendNewControlValue(proc, Return, Origin(), result);
2406		2414
2407	CHECK(isIdentical(compileAndRun<double>(proc, a, b), bitAndDouble(a, b)));	2415	CHECK(isIdentical(compileAndRun<double>(proc, a, b), bitAndDouble(a, b)));
2408	}	2416	}
Lines 2414-2420 void testBitAndImmsDouble(double a, doub Source/JavaScriptCore/b3/testb3.cpp_sec140
2414	Value* argumentA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	2422	Value* argumentA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
2415	Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	2423	Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
2416	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);	2424	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);
2417	root->appendNew<ControlValue>(proc, Return, Origin(), result);	2425	root->appendNewControlValue(proc, Return, Origin(), result);
2418		2426
2419	CHECK(isIdentical(compileAndRun<double>(proc), bitAndDouble(a, b)));	2427	CHECK(isIdentical(compileAndRun<double>(proc), bitAndDouble(a, b)));
2420	}	2428	}
Lines 2432-2438 void testBitAndArgFloat(float a) Source/JavaScriptCore/b3/testb3.cpp_sec141
2432	root->appendNew<Value>(proc, Trunc, Origin(),	2440	root->appendNew<Value>(proc, Trunc, Origin(),
2433	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));	2441	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
2434	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argument, argument);	2442	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argument, argument);
2435	root->appendNew<ControlValue>(proc, Return, Origin(), result);	2443	root->appendNewControlValue(proc, Return, Origin(), result);
2436		2444
2437	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), bitAndFloat(a, a)));	2445	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), bitAndFloat(a, a)));
2438	}	2446	}
Lines 2448-2454 void testBitAndArgsFloat(float a, float Source/JavaScriptCore/b3/testb3.cpp_sec142
2448	root->appendNew<Value>(proc, Trunc, Origin(),	2456	root->appendNew<Value>(proc, Trunc, Origin(),
2449	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1)));	2457	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1)));
2450	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);	2458	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);
2451	root->appendNew<ControlValue>(proc, Return, Origin(), result);	2459	root->appendNewControlValue(proc, Return, Origin(), result);
2452		2460
2453	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitAndFloat(a, b)));	2461	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitAndFloat(a, b)));
2454	}	2462	}
Lines 2462-2468 void testBitAndArgImmFloat(float a, floa Source/JavaScriptCore/b3/testb3.cpp_sec143
2462	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));	2470	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
2463	Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);	2471	Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);
2464	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);	2472	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);
2465	root->appendNew<ControlValue>(proc, Return, Origin(), result);	2473	root->appendNewControlValue(proc, Return, Origin(), result);
2466		2474
2467	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitAndFloat(a, b)));	2475	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitAndFloat(a, b)));
2468	}	2476	}
Lines 2474-2480 void testBitAndImmsFloat(float a, float Source/JavaScriptCore/b3/testb3.cpp_sec144
2474	Value* argumentA = root->appendNew<ConstFloatValue>(proc, Origin(), a);	2482	Value* argumentA = root->appendNew<ConstFloatValue>(proc, Origin(), a);
2475	Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);	2483	Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);
2476	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);	2484	Value* result = root->appendNew<Value>(proc, BitAnd, Origin(), argumentA, argumentB);
2477	root->appendNew<ControlValue>(proc, Return, Origin(), result);	2485	root->appendNewControlValue(proc, Return, Origin(), result);
2478		2486
2479	CHECK(isIdentical(compileAndRun<float>(proc), bitAndFloat(a, b)));	2487	CHECK(isIdentical(compileAndRun<float>(proc), bitAndFloat(a, b)));
2480	}	2488	}
Lines 2493-2499 void testBitAndArgsFloatWithUselessDoubl Source/JavaScriptCore/b3/testb3.cpp_sec145
2493	Value* argumentBasDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argumentB);	2501	Value* argumentBasDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argumentB);
2494	Value* doubleResult = root->appendNew<Value>(proc, BitAnd, Origin(), argumentAasDouble, argumentBasDouble);	2502	Value* doubleResult = root->appendNew<Value>(proc, BitAnd, Origin(), argumentAasDouble, argumentBasDouble);
2495	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), doubleResult);	2503	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), doubleResult);
2496	root->appendNew<ControlValue>(proc, Return, Origin(), floatResult);	2504	root->appendNewControlValue(proc, Return, Origin(), floatResult);
2497		2505
2498	double doubleA = a;	2506	double doubleA = a;
2499	double doubleB = b;	2507	double doubleB = b;
Lines 2505-2511 void testBitOrArgs(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec146
2505	{	2513	{
2506	Procedure proc;	2514	Procedure proc;
2507	BasicBlock* root = proc.addBlock();	2515	BasicBlock* root = proc.addBlock();
2508	root->appendNew<ControlValue>(	2516	root->appendNewControlValue(
2509	proc, Return, Origin(),	2517	proc, Return, Origin(),
2510	root->appendNew<Value>(	2518	root->appendNew<Value>(
2511	proc, BitOr, Origin(),	2519	proc, BitOr, Origin(),
Lines 2520-2526 void testBitOrSameArg(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec147
2520	Procedure proc;	2528	Procedure proc;
2521	BasicBlock* root = proc.addBlock();	2529	BasicBlock* root = proc.addBlock();
2522	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	2530	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
2523	root->appendNew<ControlValue>(	2531	root->appendNewControlValue(
2524	proc, Return, Origin(),	2532	proc, Return, Origin(),
2525	root->appendNew<Value>(	2533	root->appendNew<Value>(
2526	proc, BitOr, Origin(),	2534	proc, BitOr, Origin(),
Lines 2534-2540 void testBitOrImms(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec148
2534	{	2542	{
2535	Procedure proc;	2543	Procedure proc;
2536	BasicBlock* root = proc.addBlock();	2544	BasicBlock* root = proc.addBlock();
2537	root->appendNew<ControlValue>(	2545	root->appendNewControlValue(
2538	proc, Return, Origin(),	2546	proc, Return, Origin(),
2539	root->appendNew<Value>(	2547	root->appendNew<Value>(
2540	proc, BitOr, Origin(),	2548	proc, BitOr, Origin(),
Lines 2548-2554 void testBitOrArgImm(int64_t a, int64_t Source/JavaScriptCore/b3/testb3.cpp_sec149
2548	{	2556	{
2549	Procedure proc;	2557	Procedure proc;
2550	BasicBlock* root = proc.addBlock();	2558	BasicBlock* root = proc.addBlock();
2551	root->appendNew<ControlValue>(	2559	root->appendNewControlValue(
2552	proc, Return, Origin(),	2560	proc, Return, Origin(),
2553	root->appendNew<Value>(	2561	root->appendNew<Value>(
2554	proc, BitOr, Origin(),	2562	proc, BitOr, Origin(),
Lines 2562-2568 void testBitOrImmArg(int64_t a, int64_t Source/JavaScriptCore/b3/testb3.cpp_sec150
2562	{	2570	{
2563	Procedure proc;	2571	Procedure proc;
2564	BasicBlock* root = proc.addBlock();	2572	BasicBlock* root = proc.addBlock();
2565	root->appendNew<ControlValue>(	2573	root->appendNewControlValue(
2566	proc, Return, Origin(),	2574	proc, Return, Origin(),
2567	root->appendNew<Value>(	2575	root->appendNew<Value>(
2568	proc, BitOr, Origin(),	2576	proc, BitOr, Origin(),
Lines 2580-2586 void testBitOrBitOrArgImmImm(int64_t a, Source/JavaScriptCore/b3/testb3.cpp_sec151
2580	proc, BitOr, Origin(),	2588	proc, BitOr, Origin(),
2581	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	2589	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
2582	root->appendNew<Const64Value>(proc, Origin(), b));	2590	root->appendNew<Const64Value>(proc, Origin(), b));
2583	root->appendNew<ControlValue>(	2591	root->appendNewControlValue(
2584	proc, Return, Origin(),	2592	proc, Return, Origin(),
2585	root->appendNew<Value>(	2593	root->appendNew<Value>(
2586	proc, BitOr, Origin(),	2594	proc, BitOr, Origin(),
Lines 2598-2604 void testBitOrImmBitOrArgImm(int64_t a, Source/JavaScriptCore/b3/testb3.cpp_sec152
2598	proc, BitOr, Origin(),	2606	proc, BitOr, Origin(),
2599	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	2607	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
2600	root->appendNew<Const64Value>(proc, Origin(), c));	2608	root->appendNew<Const64Value>(proc, Origin(), c));
2601	root->appendNew<ControlValue>(	2609	root->appendNewControlValue(
2602	proc, Return, Origin(),	2610	proc, Return, Origin(),
2603	root->appendNew<Value>(	2611	root->appendNew<Value>(
2604	proc, BitOr, Origin(),	2612	proc, BitOr, Origin(),
Lines 2612-2618 void testBitOrArgs32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec153
2612	{	2620	{
2613	Procedure proc;	2621	Procedure proc;
2614	BasicBlock* root = proc.addBlock();	2622	BasicBlock* root = proc.addBlock();
2615	root->appendNew<ControlValue>(	2623	root->appendNewControlValue(
2616	proc, Return, Origin(),	2624	proc, Return, Origin(),
2617	root->appendNew<Value>(	2625	root->appendNew<Value>(
2618	proc, BitOr, Origin(),	2626	proc, BitOr, Origin(),
Lines 2633-2639 void testBitOrSameArg32(int a) Source/JavaScriptCore/b3/testb3.cpp_sec154
2633	Value* argument = root->appendNew<Value>(	2641	Value* argument = root->appendNew<Value>(
2634	proc, Trunc, Origin(),	2642	proc, Trunc, Origin(),
2635	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	2643	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
2636	root->appendNew<ControlValue>(	2644	root->appendNewControlValue(
2637	proc, Return, Origin(),	2645	proc, Return, Origin(),
2638	root->appendNew<Value>(	2646	root->appendNew<Value>(
2639	proc, BitOr, Origin(),	2647	proc, BitOr, Origin(),
Lines 2647-2653 void testBitOrImms32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec155
2647	{	2655	{
2648	Procedure proc;	2656	Procedure proc;
2649	BasicBlock* root = proc.addBlock();	2657	BasicBlock* root = proc.addBlock();
2650	root->appendNew<ControlValue>(	2658	root->appendNewControlValue(
2651	proc, Return, Origin(),	2659	proc, Return, Origin(),
2652	root->appendNew<Value>(	2660	root->appendNew<Value>(
2653	proc, BitOr, Origin(),	2661	proc, BitOr, Origin(),
Lines 2661-2667 void testBitOrArgImm32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec156
2661	{	2669	{
2662	Procedure proc;	2670	Procedure proc;
2663	BasicBlock* root = proc.addBlock();	2671	BasicBlock* root = proc.addBlock();
2664	root->appendNew<ControlValue>(	2672	root->appendNewControlValue(
2665	proc, Return, Origin(),	2673	proc, Return, Origin(),
2666	root->appendNew<Value>(	2674	root->appendNew<Value>(
2667	proc, BitOr, Origin(),	2675	proc, BitOr, Origin(),
Lines 2677-2683 void testBitOrImmArg32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec157
2677	{	2685	{
2678	Procedure proc;	2686	Procedure proc;
2679	BasicBlock* root = proc.addBlock();	2687	BasicBlock* root = proc.addBlock();
2680	root->appendNew<ControlValue>(	2688	root->appendNewControlValue(
2681	proc, Return, Origin(),	2689	proc, Return, Origin(),
2682	root->appendNew<Value>(	2690	root->appendNew<Value>(
2683	proc, BitOr, Origin(),	2691	proc, BitOr, Origin(),
Lines 2699-2705 void testBitOrBitOrArgImmImm32(int a, in Source/JavaScriptCore/b3/testb3.cpp_sec158
2699	proc, Trunc, Origin(),	2707	proc, Trunc, Origin(),
2700	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	2708	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
2701	root->appendNew<Const32Value>(proc, Origin(), b));	2709	root->appendNew<Const32Value>(proc, Origin(), b));
2702	root->appendNew<ControlValue>(	2710	root->appendNewControlValue(
2703	proc, Return, Origin(),	2711	proc, Return, Origin(),
2704	root->appendNew<Value>(	2712	root->appendNew<Value>(
2705	proc, BitOr, Origin(),	2713	proc, BitOr, Origin(),
Lines 2719-2725 void testBitOrImmBitOrArgImm32(int a, in Source/JavaScriptCore/b3/testb3.cpp_sec159
2719	proc, Trunc, Origin(),	2727	proc, Trunc, Origin(),
2720	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	2728	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
2721	root->appendNew<Const32Value>(proc, Origin(), c));	2729	root->appendNew<Const32Value>(proc, Origin(), c));
2722	root->appendNew<ControlValue>(	2730	root->appendNewControlValue(
2723	proc, Return, Origin(),	2731	proc, Return, Origin(),
2724	root->appendNew<Value>(	2732	root->appendNew<Value>(
2725	proc, BitOr, Origin(),	2733	proc, BitOr, Origin(),
Lines 2733-2739 void testBitXorArgs(int64_t a, int64_t b Source/JavaScriptCore/b3/testb3.cpp_sec160
2733	{	2741	{
2734	Procedure proc;	2742	Procedure proc;
2735	BasicBlock* root = proc.addBlock();	2743	BasicBlock* root = proc.addBlock();
2736	root->appendNew<ControlValue>(	2744	root->appendNewControlValue(
2737	proc, Return, Origin(),	2745	proc, Return, Origin(),
2738	root->appendNew<Value>(	2746	root->appendNew<Value>(
2739	proc, BitXor, Origin(),	2747	proc, BitXor, Origin(),
Lines 2748-2754 void testBitXorSameArg(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec161
2748	Procedure proc;	2756	Procedure proc;
2749	BasicBlock* root = proc.addBlock();	2757	BasicBlock* root = proc.addBlock();
2750	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	2758	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
2751	root->appendNew<ControlValue>(	2759	root->appendNewControlValue(
2752	proc, Return, Origin(),	2760	proc, Return, Origin(),
2753	root->appendNew<Value>(	2761	root->appendNew<Value>(
2754	proc, BitXor, Origin(),	2762	proc, BitXor, Origin(),
Lines 2762-2768 void testBitXorImms(int64_t a, int64_t b Source/JavaScriptCore/b3/testb3.cpp_sec162
2762	{	2770	{
2763	Procedure proc;	2771	Procedure proc;
2764	BasicBlock* root = proc.addBlock();	2772	BasicBlock* root = proc.addBlock();
2765	root->appendNew<ControlValue>(	2773	root->appendNewControlValue(
2766	proc, Return, Origin(),	2774	proc, Return, Origin(),
2767	root->appendNew<Value>(	2775	root->appendNew<Value>(
2768	proc, BitXor, Origin(),	2776	proc, BitXor, Origin(),
Lines 2776-2782 void testBitXorArgImm(int64_t a, int64_t Source/JavaScriptCore/b3/testb3.cpp_sec163
2776	{	2784	{
2777	Procedure proc;	2785	Procedure proc;
2778	BasicBlock* root = proc.addBlock();	2786	BasicBlock* root = proc.addBlock();
2779	root->appendNew<ControlValue>(	2787	root->appendNewControlValue(
2780	proc, Return, Origin(),	2788	proc, Return, Origin(),
2781	root->appendNew<Value>(	2789	root->appendNew<Value>(
2782	proc, BitXor, Origin(),	2790	proc, BitXor, Origin(),
Lines 2790-2796 void testBitXorImmArg(int64_t a, int64_t Source/JavaScriptCore/b3/testb3.cpp_sec164
2790	{	2798	{
2791	Procedure proc;	2799	Procedure proc;
2792	BasicBlock* root = proc.addBlock();	2800	BasicBlock* root = proc.addBlock();
2793	root->appendNew<ControlValue>(	2801	root->appendNewControlValue(
2794	proc, Return, Origin(),	2802	proc, Return, Origin(),
2795	root->appendNew<Value>(	2803	root->appendNew<Value>(
2796	proc, BitXor, Origin(),	2804	proc, BitXor, Origin(),
Lines 2808-2814 void testBitXorBitXorArgImmImm(int64_t a Source/JavaScriptCore/b3/testb3.cpp_sec165
2808	proc, BitXor, Origin(),	2816	proc, BitXor, Origin(),
2809	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	2817	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
2810	root->appendNew<Const64Value>(proc, Origin(), b));	2818	root->appendNew<Const64Value>(proc, Origin(), b));
2811	root->appendNew<ControlValue>(	2819	root->appendNewControlValue(
2812	proc, Return, Origin(),	2820	proc, Return, Origin(),
2813	root->appendNew<Value>(	2821	root->appendNew<Value>(
2814	proc, BitXor, Origin(),	2822	proc, BitXor, Origin(),
Lines 2826-2832 void testBitXorImmBitXorArgImm(int64_t a Source/JavaScriptCore/b3/testb3.cpp_sec166
2826	proc, BitXor, Origin(),	2834	proc, BitXor, Origin(),
2827	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	2835	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
2828	root->appendNew<Const64Value>(proc, Origin(), c));	2836	root->appendNew<Const64Value>(proc, Origin(), c));
2829	root->appendNew<ControlValue>(	2837	root->appendNewControlValue(
2830	proc, Return, Origin(),	2838	proc, Return, Origin(),
2831	root->appendNew<Value>(	2839	root->appendNew<Value>(
2832	proc, BitXor, Origin(),	2840	proc, BitXor, Origin(),
Lines 2840-2846 void testBitXorArgs32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec167
2840	{	2848	{
2841	Procedure proc;	2849	Procedure proc;
2842	BasicBlock* root = proc.addBlock();	2850	BasicBlock* root = proc.addBlock();
2843	root->appendNew<ControlValue>(	2851	root->appendNewControlValue(
2844	proc, Return, Origin(),	2852	proc, Return, Origin(),
2845	root->appendNew<Value>(	2853	root->appendNew<Value>(
2846	proc, BitXor, Origin(),	2854	proc, BitXor, Origin(),
Lines 2861-2867 void testBitXorSameArg32(int a) Source/JavaScriptCore/b3/testb3.cpp_sec168
2861	Value* argument = root->appendNew<Value>(	2869	Value* argument = root->appendNew<Value>(
2862	proc, Trunc, Origin(),	2870	proc, Trunc, Origin(),
2863	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	2871	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
2864	root->appendNew<ControlValue>(	2872	root->appendNewControlValue(
2865	proc, Return, Origin(),	2873	proc, Return, Origin(),
2866	root->appendNew<Value>(	2874	root->appendNew<Value>(
2867	proc, BitXor, Origin(),	2875	proc, BitXor, Origin(),
Lines 2875-2881 void testBitXorImms32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec169
2875	{	2883	{
2876	Procedure proc;	2884	Procedure proc;
2877	BasicBlock* root = proc.addBlock();	2885	BasicBlock* root = proc.addBlock();
2878	root->appendNew<ControlValue>(	2886	root->appendNewControlValue(
2879	proc, Return, Origin(),	2887	proc, Return, Origin(),
2880	root->appendNew<Value>(	2888	root->appendNew<Value>(
2881	proc, BitXor, Origin(),	2889	proc, BitXor, Origin(),
Lines 2889-2895 void testBitXorArgImm32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec170
2889	{	2897	{
2890	Procedure proc;	2898	Procedure proc;
2891	BasicBlock* root = proc.addBlock();	2899	BasicBlock* root = proc.addBlock();
2892	root->appendNew<ControlValue>(	2900	root->appendNewControlValue(
2893	proc, Return, Origin(),	2901	proc, Return, Origin(),
2894	root->appendNew<Value>(	2902	root->appendNew<Value>(
2895	proc, BitXor, Origin(),	2903	proc, BitXor, Origin(),
Lines 2905-2911 void testBitXorImmArg32(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec171
2905	{	2913	{
2906	Procedure proc;	2914	Procedure proc;
2907	BasicBlock* root = proc.addBlock();	2915	BasicBlock* root = proc.addBlock();
2908	root->appendNew<ControlValue>(	2916	root->appendNewControlValue(
2909	proc, Return, Origin(),	2917	proc, Return, Origin(),
2910	root->appendNew<Value>(	2918	root->appendNew<Value>(
2911	proc, BitXor, Origin(),	2919	proc, BitXor, Origin(),
Lines 2927-2933 void testBitXorBitXorArgImmImm32(int a, Source/JavaScriptCore/b3/testb3.cpp_sec172
2927	proc, Trunc, Origin(),	2935	proc, Trunc, Origin(),
2928	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	2936	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
2929	root->appendNew<Const32Value>(proc, Origin(), b));	2937	root->appendNew<Const32Value>(proc, Origin(), b));
2930	root->appendNew<ControlValue>(	2938	root->appendNewControlValue(
2931	proc, Return, Origin(),	2939	proc, Return, Origin(),
2932	root->appendNew<Value>(	2940	root->appendNew<Value>(
2933	proc, BitXor, Origin(),	2941	proc, BitXor, Origin(),
Lines 2947-2953 void testBitXorImmBitXorArgImm32(int a, Source/JavaScriptCore/b3/testb3.cpp_sec173
2947	proc, Trunc, Origin(),	2955	proc, Trunc, Origin(),
2948	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	2956	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
2949	root->appendNew<Const32Value>(proc, Origin(), c));	2957	root->appendNew<Const32Value>(proc, Origin(), c));
2950	root->appendNew<ControlValue>(	2958	root->appendNewControlValue(
2951	proc, Return, Origin(),	2959	proc, Return, Origin(),
2952	root->appendNew<Value>(	2960	root->appendNew<Value>(
2953	proc, BitXor, Origin(),	2961	proc, BitXor, Origin(),
Lines 2961-2967 void testBitNotArg(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec174
2961	{	2969	{
2962	Procedure proc;	2970	Procedure proc;
2963	BasicBlock* root = proc.addBlock();	2971	BasicBlock* root = proc.addBlock();
2964	root->appendNew<ControlValue>(	2972	root->appendNewControlValue(
2965	proc, Return, Origin(),	2973	proc, Return, Origin(),
2966	root->appendNew<Value>(	2974	root->appendNew<Value>(
2967	proc, BitXor, Origin(),	2975	proc, BitXor, Origin(),
Lines 2975-2981 void testBitNotImm(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec175
2975	{	2983	{
2976	Procedure proc;	2984	Procedure proc;
2977	BasicBlock* root = proc.addBlock();	2985	BasicBlock* root = proc.addBlock();
2978	root->appendNew<ControlValue>(	2986	root->appendNewControlValue(
2979	proc, Return, Origin(),	2987	proc, Return, Origin(),
2980	root->appendNew<Value>(	2988	root->appendNew<Value>(
2981	proc, BitXor, Origin(),	2989	proc, BitXor, Origin(),
Lines 2995-3001 void testBitNotMem(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec176
2995	root->appendNew<Const64Value>(proc, Origin(), -1),	3003	root->appendNew<Const64Value>(proc, Origin(), -1),
2996	load);	3004	load);
2997	root->appendNew<MemoryValue>(proc, Store, Origin(), notLoad, address);	3005	root->appendNew<MemoryValue>(proc, Store, Origin(), notLoad, address);
2998	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	3006	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
2999		3007
3000	int64_t input = a;	3008	int64_t input = a;
3001	compileAndRun<int32_t>(proc, &input);	3009	compileAndRun<int32_t>(proc, &input);
Lines 3008-3014 void testBitNotArg32(int32_t a) Source/JavaScriptCore/b3/testb3.cpp_sec177
3008	BasicBlock* root = proc.addBlock();	3016	BasicBlock* root = proc.addBlock();
3009	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),	3017	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),
3010	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	3018	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
3011	root->appendNew<ControlValue>(	3019	root->appendNewControlValue(
3012	proc, Return, Origin(),	3020	proc, Return, Origin(),
3013	root->appendNew<Value>(proc, BitXor, Origin(),	3021	root->appendNew<Value>(proc, BitXor, Origin(),
3014	root->appendNew<Const32Value>(proc, Origin(), -1),	3022	root->appendNew<Const32Value>(proc, Origin(), -1),
Lines 3020-3026 void testBitNotImm32(int32_t a) Source/JavaScriptCore/b3/testb3.cpp_sec178
3020	{	3028	{
3021	Procedure proc;	3029	Procedure proc;
3022	BasicBlock* root = proc.addBlock();	3030	BasicBlock* root = proc.addBlock();
3023	root->appendNew<ControlValue>(	3031	root->appendNewControlValue(
3024	proc, Return, Origin(),	3032	proc, Return, Origin(),
3025	root->appendNew<Value>(	3033	root->appendNew<Value>(
3026	proc, BitXor, Origin(),	3034	proc, BitXor, Origin(),
Lines 3040-3046 void testBitNotMem32(int32_t a) Source/JavaScriptCore/b3/testb3.cpp_sec179
3040	root->appendNew<Const32Value>(proc, Origin(), -1),	3048	root->appendNew<Const32Value>(proc, Origin(), -1),
3041	load);	3049	load);
3042	root->appendNew<MemoryValue>(proc, Store, Origin(), notLoad, address);	3050	root->appendNew<MemoryValue>(proc, Store, Origin(), notLoad, address);
3043	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	3051	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
3044		3052
3045	int32_t input = a;	3053	int32_t input = a;
3046	compileAndRun<int32_t>(proc, &input);	3054	compileAndRun<int32_t>(proc, &input);
Lines 3063-3078 void testBitNotOnBooleanAndBranch32(int6 Source/JavaScriptCore/b3/testb3.cpp_sec180
3063	root->appendNew<Const32Value>(proc, Origin(), -1),	3071	root->appendNew<Const32Value>(proc, Origin(), -1),
3064	argsAreEqual);	3072	argsAreEqual);
3065		3073
3066	root->appendNew<ControlValue>(	3074	root->appendNewControlValue(
3067	proc, Branch, Origin(),	3075	proc, Branch, Origin(),
3068	argsAreNotEqual,	3076	argsAreNotEqual,
3069	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	3077	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
3070		3078
3071	thenCase->appendNew<ControlValue>(	3079	thenCase->appendNewControlValue(
3072	proc, Return, Origin(),	3080	proc, Return, Origin(),
3073	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	3081	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
3074		3082
3075	elseCase->appendNew<ControlValue>(	3083	elseCase->appendNewControlValue(
3076	proc, Return, Origin(),	3084	proc, Return, Origin(),
3077	elseCase->appendNew<Const32Value>(proc, Origin(), -42));	3085	elseCase->appendNew<Const32Value>(proc, Origin(), -42));
3078		3086
Lines 3084-3090 void testShlArgs(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec181
3084	{	3092	{
3085	Procedure proc;	3093	Procedure proc;
3086	BasicBlock* root = proc.addBlock();	3094	BasicBlock* root = proc.addBlock();
3087	root->appendNew<ControlValue>(	3095	root->appendNewControlValue(
3088	proc, Return, Origin(),	3096	proc, Return, Origin(),
3089	root->appendNew<Value>(	3097	root->appendNew<Value>(
3090	proc, Shl, Origin(),	3098	proc, Shl, Origin(),
Lines 3100-3106 void testShlImms(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec182
3100	{	3108	{
3101	Procedure proc;	3109	Procedure proc;
3102	BasicBlock* root = proc.addBlock();	3110	BasicBlock* root = proc.addBlock();
3103	root->appendNew<ControlValue>(	3111	root->appendNewControlValue(
3104	proc, Return, Origin(),	3112	proc, Return, Origin(),
3105	root->appendNew<Value>(	3113	root->appendNew<Value>(
3106	proc, Shl, Origin(),	3114	proc, Shl, Origin(),
Lines 3114-3120 void testShlArgImm(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec183
3114	{	3122	{
3115	Procedure proc;	3123	Procedure proc;
3116	BasicBlock* root = proc.addBlock();	3124	BasicBlock* root = proc.addBlock();
3117	root->appendNew<ControlValue>(	3125	root->appendNewControlValue(
3118	proc, Return, Origin(),	3126	proc, Return, Origin(),
3119	root->appendNew<Value>(	3127	root->appendNew<Value>(
3120	proc, Shl, Origin(),	3128	proc, Shl, Origin(),
Lines 3131-3137 void testShlArg32(int32_t a) Source/JavaScriptCore/b3/testb3.cpp_sec184
3131	Value* value = root->appendNew<Value>(	3139	Value* value = root->appendNew<Value>(
3132	proc, Trunc, Origin(),	3140	proc, Trunc, Origin(),
3133	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	3141	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
3134	root->appendNew<ControlValue>(	3142	root->appendNewControlValue(
3135	proc, Return, Origin(),	3143	proc, Return, Origin(),
3136	root->appendNew<Value>(proc, Shl, Origin(), value, value));	3144	root->appendNew<Value>(proc, Shl, Origin(), value, value));
3137		3145
Lines 3142-3148 void testShlArgs32(int32_t a, int32_t b) Source/JavaScriptCore/b3/testb3.cpp_sec185
3142	{	3150	{
3143	Procedure proc;	3151	Procedure proc;
3144	BasicBlock* root = proc.addBlock();	3152	BasicBlock* root = proc.addBlock();
3145	root->appendNew<ControlValue>(	3153	root->appendNewControlValue(
3146	proc, Return, Origin(),	3154	proc, Return, Origin(),
3147	root->appendNew<Value>(	3155	root->appendNew<Value>(
3148	proc, Shl, Origin(),	3156	proc, Shl, Origin(),
Lines 3160-3166 void testShlImms32(int32_t a, int32_t b) Source/JavaScriptCore/b3/testb3.cpp_sec186
3160	{	3168	{
3161	Procedure proc;	3169	Procedure proc;
3162	BasicBlock* root = proc.addBlock();	3170	BasicBlock* root = proc.addBlock();
3163	root->appendNew<ControlValue>(	3171	root->appendNewControlValue(
3164	proc, Return, Origin(),	3172	proc, Return, Origin(),
3165	root->appendNew<Value>(	3173	root->appendNew<Value>(
3166	proc, Shl, Origin(),	3174	proc, Shl, Origin(),
Lines 3174-3180 void testShlArgImm32(int32_t a, int32_t Source/JavaScriptCore/b3/testb3.cpp_sec187
3174	{	3182	{
3175	Procedure proc;	3183	Procedure proc;
3176	BasicBlock* root = proc.addBlock();	3184	BasicBlock* root = proc.addBlock();
3177	root->appendNew<ControlValue>(	3185	root->appendNewControlValue(
3178	proc, Return, Origin(),	3186	proc, Return, Origin(),
3179	root->appendNew<Value>(	3187	root->appendNew<Value>(
3180	proc, Shl, Origin(),	3188	proc, Shl, Origin(),
Lines 3190-3196 void testSShrArgs(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec188
3190	{	3198	{
3191	Procedure proc;	3199	Procedure proc;
3192	BasicBlock* root = proc.addBlock();	3200	BasicBlock* root = proc.addBlock();
3193	root->appendNew<ControlValue>(	3201	root->appendNewControlValue(
3194	proc, Return, Origin(),	3202	proc, Return, Origin(),
3195	root->appendNew<Value>(	3203	root->appendNew<Value>(
3196	proc, SShr, Origin(),	3204	proc, SShr, Origin(),
Lines 3206-3212 void testSShrImms(int64_t a, int64_t b) Source/JavaScriptCore/b3/testb3.cpp_sec189
3206	{	3214	{
3207	Procedure proc;	3215	Procedure proc;
3208	BasicBlock* root = proc.addBlock();	3216	BasicBlock* root = proc.addBlock();
3209	root->appendNew<ControlValue>(	3217	root->appendNewControlValue(
3210	proc, Return, Origin(),	3218	proc, Return, Origin(),
3211	root->appendNew<Value>(	3219	root->appendNew<Value>(
3212	proc, SShr, Origin(),	3220	proc, SShr, Origin(),
Lines 3220-3226 void testSShrArgImm(int64_t a, int64_t b Source/JavaScriptCore/b3/testb3.cpp_sec190
3220	{	3228	{
3221	Procedure proc;	3229	Procedure proc;
3222	BasicBlock* root = proc.addBlock();	3230	BasicBlock* root = proc.addBlock();
3223	root->appendNew<ControlValue>(	3231	root->appendNewControlValue(
3224	proc, Return, Origin(),	3232	proc, Return, Origin(),
3225	root->appendNew<Value>(	3233	root->appendNew<Value>(
3226	proc, SShr, Origin(),	3234	proc, SShr, Origin(),
Lines 3237-3243 void testSShrArg32(int32_t a) Source/JavaScriptCore/b3/testb3.cpp_sec191
3237	Value* value = root->appendNew<Value>(	3245	Value* value = root->appendNew<Value>(
3238	proc, Trunc, Origin(),	3246	proc, Trunc, Origin(),
3239	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	3247	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
3240	root->appendNew<ControlValue>(	3248	root->appendNewControlValue(
3241	proc, Return, Origin(),	3249	proc, Return, Origin(),
3242	root->appendNew<Value>(proc, SShr, Origin(), value, value));	3250	root->appendNew<Value>(proc, SShr, Origin(), value, value));
3243		3251
Lines 3248-3254 void testSShrArgs32(int32_t a, int32_t b Source/JavaScriptCore/b3/testb3.cpp_sec192
3248	{	3256	{
3249	Procedure proc;	3257	Procedure proc;
3250	BasicBlock* root = proc.addBlock();	3258	BasicBlock* root = proc.addBlock();
3251	root->appendNew<ControlValue>(	3259	root->appendNewControlValue(
3252	proc, Return, Origin(),	3260	proc, Return, Origin(),
3253	root->appendNew<Value>(	3261	root->appendNew<Value>(
3254	proc, SShr, Origin(),	3262	proc, SShr, Origin(),
Lines 3266-3272 void testSShrImms32(int32_t a, int32_t b Source/JavaScriptCore/b3/testb3.cpp_sec193
3266	{	3274	{
3267	Procedure proc;	3275	Procedure proc;
3268	BasicBlock* root = proc.addBlock();	3276	BasicBlock* root = proc.addBlock();
3269	root->appendNew<ControlValue>(	3277	root->appendNewControlValue(
3270	proc, Return, Origin(),	3278	proc, Return, Origin(),
3271	root->appendNew<Value>(	3279	root->appendNew<Value>(
3272	proc, SShr, Origin(),	3280	proc, SShr, Origin(),
Lines 3280-3286 void testSShrArgImm32(int32_t a, int32_t Source/JavaScriptCore/b3/testb3.cpp_sec194
3280	{	3288	{
3281	Procedure proc;	3289	Procedure proc;
3282	BasicBlock* root = proc.addBlock();	3290	BasicBlock* root = proc.addBlock();
3283	root->appendNew<ControlValue>(	3291	root->appendNewControlValue(
3284	proc, Return, Origin(),	3292	proc, Return, Origin(),
3285	root->appendNew<Value>(	3293	root->appendNew<Value>(
3286	proc, SShr, Origin(),	3294	proc, SShr, Origin(),
Lines 3296-3302 void testZShrArgs(uint64_t a, uint64_t b Source/JavaScriptCore/b3/testb3.cpp_sec195
3296	{	3304	{
3297	Procedure proc;	3305	Procedure proc;
3298	BasicBlock* root = proc.addBlock();	3306	BasicBlock* root = proc.addBlock();
3299	root->appendNew<ControlValue>(	3307	root->appendNewControlValue(
3300	proc, Return, Origin(),	3308	proc, Return, Origin(),
3301	root->appendNew<Value>(	3309	root->appendNew<Value>(
3302	proc, ZShr, Origin(),	3310	proc, ZShr, Origin(),
Lines 3312-3318 void testZShrImms(uint64_t a, uint64_t b Source/JavaScriptCore/b3/testb3.cpp_sec196
3312	{	3320	{
3313	Procedure proc;	3321	Procedure proc;
3314	BasicBlock* root = proc.addBlock();	3322	BasicBlock* root = proc.addBlock();
3315	root->appendNew<ControlValue>(	3323	root->appendNewControlValue(
3316	proc, Return, Origin(),	3324	proc, Return, Origin(),
3317	root->appendNew<Value>(	3325	root->appendNew<Value>(
3318	proc, ZShr, Origin(),	3326	proc, ZShr, Origin(),
Lines 3326-3332 void testZShrArgImm(uint64_t a, uint64_t Source/JavaScriptCore/b3/testb3.cpp_sec197
3326	{	3334	{
3327	Procedure proc;	3335	Procedure proc;
3328	BasicBlock* root = proc.addBlock();	3336	BasicBlock* root = proc.addBlock();
3329	root->appendNew<ControlValue>(	3337	root->appendNewControlValue(
3330	proc, Return, Origin(),	3338	proc, Return, Origin(),
3331	root->appendNew<Value>(	3339	root->appendNew<Value>(
3332	proc, ZShr, Origin(),	3340	proc, ZShr, Origin(),
Lines 3343-3349 void testZShrArg32(uint32_t a) Source/JavaScriptCore/b3/testb3.cpp_sec198
3343	Value* value = root->appendNew<Value>(	3351	Value* value = root->appendNew<Value>(
3344	proc, Trunc, Origin(),	3352	proc, Trunc, Origin(),
3345	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	3353	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
3346	root->appendNew<ControlValue>(	3354	root->appendNewControlValue(
3347	proc, Return, Origin(),	3355	proc, Return, Origin(),
3348	root->appendNew<Value>(proc, ZShr, Origin(), value, value));	3356	root->appendNew<Value>(proc, ZShr, Origin(), value, value));
3349		3357
Lines 3354-3360 void testZShrArgs32(uint32_t a, uint32_t Source/JavaScriptCore/b3/testb3.cpp_sec199
3354	{	3362	{
3355	Procedure proc;	3363	Procedure proc;
3356	BasicBlock* root = proc.addBlock();	3364	BasicBlock* root = proc.addBlock();
3357	root->appendNew<ControlValue>(	3365	root->appendNewControlValue(
3358	proc, Return, Origin(),	3366	proc, Return, Origin(),
3359	root->appendNew<Value>(	3367	root->appendNew<Value>(
3360	proc, ZShr, Origin(),	3368	proc, ZShr, Origin(),
Lines 3372-3378 void testZShrImms32(uint32_t a, uint32_t Source/JavaScriptCore/b3/testb3.cpp_sec200
3372	{	3380	{
3373	Procedure proc;	3381	Procedure proc;
3374	BasicBlock* root = proc.addBlock();	3382	BasicBlock* root = proc.addBlock();
3375	root->appendNew<ControlValue>(	3383	root->appendNewControlValue(
3376	proc, Return, Origin(),	3384	proc, Return, Origin(),
3377	root->appendNew<Value>(	3385	root->appendNew<Value>(
3378	proc, ZShr, Origin(),	3386	proc, ZShr, Origin(),
Lines 3386-3392 void testZShrArgImm32(uint32_t a, uint32 Source/JavaScriptCore/b3/testb3.cpp_sec201
3386	{	3394	{
3387	Procedure proc;	3395	Procedure proc;
3388	BasicBlock* root = proc.addBlock();	3396	BasicBlock* root = proc.addBlock();
3389	root->appendNew<ControlValue>(	3397	root->appendNewControlValue(
3390	proc, Return, Origin(),	3398	proc, Return, Origin(),
3391	root->appendNew<Value>(	3399	root->appendNew<Value>(
3392	proc, ZShr, Origin(),	3400	proc, ZShr, Origin(),
Lines 3419-3425 void testClzArg64(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec202
3419	BasicBlock* root = proc.addBlock();	3427	BasicBlock* root = proc.addBlock();
3420	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	3428	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
3421	Value* clzValue = root->appendNew<Value>(proc, Clz, Origin(), argument);	3429	Value* clzValue = root->appendNew<Value>(proc, Clz, Origin(), argument);
3422	root->appendNew<ControlValue>(proc, Return, Origin(), clzValue);	3430	root->appendNewControlValue(proc, Return, Origin(), clzValue);
3423	CHECK(compileAndRun<unsigned>(proc, a) == countLeadingZero(a));	3431	CHECK(compileAndRun<unsigned>(proc, a) == countLeadingZero(a));
3424	}	3432	}
3425		3433
Lines 3430-3436 void testClzMem64(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec203
3430	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	3438	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
3431	MemoryValue* value = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);	3439	MemoryValue* value = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);
3432	Value* clzValue = root->appendNew<Value>(proc, Clz, Origin(), value);	3440	Value* clzValue = root->appendNew<Value>(proc, Clz, Origin(), value);
3433	root->appendNew<ControlValue>(proc, Return, Origin(), clzValue);	3441	root->appendNewControlValue(proc, Return, Origin(), clzValue);
3434	CHECK(compileAndRun<unsigned>(proc, &a) == countLeadingZero(a));	3442	CHECK(compileAndRun<unsigned>(proc, &a) == countLeadingZero(a));
3435	}	3443	}
3436		3444
Lines 3441-3447 void testClzArg32(int32_t a) Source/JavaScriptCore/b3/testb3.cpp_sec204
3441	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),	3449	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),
3442	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	3450	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
3443	Value* clzValue = root->appendNew<Value>(proc, Clz, Origin(), argument);	3451	Value* clzValue = root->appendNew<Value>(proc, Clz, Origin(), argument);
3444	root->appendNew<ControlValue>(proc, Return, Origin(), clzValue);	3452	root->appendNewControlValue(proc, Return, Origin(), clzValue);
3445	CHECK(compileAndRun<unsigned>(proc, a) == countLeadingZero(a));	3453	CHECK(compileAndRun<unsigned>(proc, a) == countLeadingZero(a));
3446	}	3454	}
3447		3455
Lines 3452-3458 void testClzMem32(int32_t a) Source/JavaScriptCore/b3/testb3.cpp_sec205
3452	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	3460	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
3453	MemoryValue* value = root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), address);	3461	MemoryValue* value = root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), address);
3454	Value* clzValue = root->appendNew<Value>(proc, Clz, Origin(), value);	3462	Value* clzValue = root->appendNew<Value>(proc, Clz, Origin(), value);
3455	root->appendNew<ControlValue>(proc, Return, Origin(), clzValue);	3463	root->appendNewControlValue(proc, Return, Origin(), clzValue);
3456	CHECK(compileAndRun<unsigned>(proc, &a) == countLeadingZero(a));	3464	CHECK(compileAndRun<unsigned>(proc, &a) == countLeadingZero(a));
3457	}	3465	}
3458		3466
Lines 3460-3466 void testAbsArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec206
3460	{	3468	{
3461	Procedure proc;	3469	Procedure proc;
3462	BasicBlock* root = proc.addBlock();	3470	BasicBlock* root = proc.addBlock();
3463	root->appendNew<ControlValue>(	3471	root->appendNewControlValue(
3464	proc, Return, Origin(),	3472	proc, Return, Origin(),
3465	root->appendNew<Value>(	3473	root->appendNew<Value>(
3466	proc, Abs, Origin(),	3474	proc, Abs, Origin(),
Lines 3474-3480 void testAbsImm(double a) Source/JavaScriptCore/b3/testb3.cpp_sec207
3474	Procedure proc;	3482	Procedure proc;
3475	BasicBlock* root = proc.addBlock();	3483	BasicBlock* root = proc.addBlock();
3476	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	3484	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
3477	root->appendNew<ControlValue>(	3485	root->appendNewControlValue(
3478	proc, Return, Origin(),	3486	proc, Return, Origin(),
3479	root->appendNew<Value>(proc, Abs, Origin(), argument));	3487	root->appendNew<Value>(proc, Abs, Origin(), argument));
3480		3488
Lines 3487-3493 void testAbsMem(double a) Source/JavaScriptCore/b3/testb3.cpp_sec208
3487	BasicBlock* root = proc.addBlock();	3495	BasicBlock* root = proc.addBlock();
3488	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	3496	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
3489	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);	3497	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);
3490	root->appendNew<ControlValue>(	3498	root->appendNewControlValue(
3491	proc, Return, Origin(),	3499	proc, Return, Origin(),
3492	root->appendNew<Value>(proc, Abs, Origin(), loadDouble));	3500	root->appendNew<Value>(proc, Abs, Origin(), loadDouble));
3493		3501
Lines 3501-3507 void testAbsAbsArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec209
3501	Value* firstAbs = root->appendNew<Value>(proc, Abs, Origin(),	3509	Value* firstAbs = root->appendNew<Value>(proc, Abs, Origin(),
3502	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));	3510	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));
3503	Value* secondAbs = root->appendNew<Value>(proc, Abs, Origin(), firstAbs);	3511	Value* secondAbs = root->appendNew<Value>(proc, Abs, Origin(), firstAbs);
3504	root->appendNew<ControlValue>(proc, Return, Origin(), secondAbs);	3512	root->appendNewControlValue(proc, Return, Origin(), secondAbs);
3505		3513
3506	CHECK(isIdentical(compileAndRun<double>(proc, a), fabs(a)));	3514	CHECK(isIdentical(compileAndRun<double>(proc, a), fabs(a)));
3507	}	3515	}
Lines 3513-3519 void testAbsBitwiseCastArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec210
3513	Value* argumentAsInt64 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	3521	Value* argumentAsInt64 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
3514	Value* argumentAsDouble = root->appendNew<Value>(proc, BitwiseCast, Origin(), argumentAsInt64);	3522	Value* argumentAsDouble = root->appendNew<Value>(proc, BitwiseCast, Origin(), argumentAsInt64);
3515	Value* absValue = root->appendNew<Value>(proc, Abs, Origin(), argumentAsDouble);	3523	Value* absValue = root->appendNew<Value>(proc, Abs, Origin(), argumentAsDouble);
3516	root->appendNew<ControlValue>(proc, Return, Origin(), absValue);	3524	root->appendNewControlValue(proc, Return, Origin(), absValue);
3517		3525
3518	CHECK(isIdentical(compileAndRun<double>(proc, bitwise_cast<int64_t>(a)), fabs(a)));	3526	CHECK(isIdentical(compileAndRun<double>(proc, bitwise_cast<int64_t>(a)), fabs(a)));
3519	}	3527	}
Lines 3527-3533 void testBitwiseCastAbsBitwiseCastArg(do Source/JavaScriptCore/b3/testb3.cpp_sec211
3527	Value* absValue = root->appendNew<Value>(proc, Abs, Origin(), argumentAsDouble);	3535	Value* absValue = root->appendNew<Value>(proc, Abs, Origin(), argumentAsDouble);
3528	Value* resultAsInt64 = root->appendNew<Value>(proc, BitwiseCast, Origin(), absValue);	3536	Value* resultAsInt64 = root->appendNew<Value>(proc, BitwiseCast, Origin(), absValue);
3529		3537
3530	root->appendNew<ControlValue>(proc, Return, Origin(), resultAsInt64);	3538	root->appendNewControlValue(proc, Return, Origin(), resultAsInt64);
3531		3539
3532	int64_t expectedResult = bitwise_cast<int64_t>(fabs(a));	3540	int64_t expectedResult = bitwise_cast<int64_t>(fabs(a));
3533	CHECK(isIdentical(compileAndRun<int64_t>(proc, bitwise_cast<int64_t>(a)), expectedResult));	3541	CHECK(isIdentical(compileAndRun<int64_t>(proc, bitwise_cast<int64_t>(a)), expectedResult));
Lines 3542-3548 void testAbsArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec212
3542	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	3550	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
3543	Value* result = root->appendNew<Value>(proc, Abs, Origin(), argument);	3551	Value* result = root->appendNew<Value>(proc, Abs, Origin(), argument);
3544	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	3552	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
3545	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3553	root->appendNewControlValue(proc, Return, Origin(), result32);
3546		3554
3547	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fabs(a)))));	3555	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fabs(a)))));
3548	}	3556	}
Lines 3554-3560 void testAbsImm(float a) Source/JavaScriptCore/b3/testb3.cpp_sec213
3554	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), a);	3562	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), a);
3555	Value* result = root->appendNew<Value>(proc, Abs, Origin(), argument);	3563	Value* result = root->appendNew<Value>(proc, Abs, Origin(), argument);
3556	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	3564	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
3557	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3565	root->appendNewControlValue(proc, Return, Origin(), result32);
3558		3566
3559	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fabs(a)))));	3567	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fabs(a)))));
3560	}	3568	}
Lines 3567-3573 void testAbsMem(float a) Source/JavaScriptCore/b3/testb3.cpp_sec214
3567	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);	3575	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);
3568	Value* result = root->appendNew<Value>(proc, Abs, Origin(), loadFloat);	3576	Value* result = root->appendNew<Value>(proc, Abs, Origin(), loadFloat);
3569	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	3577	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
3570	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3578	root->appendNewControlValue(proc, Return, Origin(), result32);
3571		3579
3572	CHECK(isIdentical(compileAndRun<int32_t>(proc, &a), bitwise_cast<int32_t>(static_cast<float>(fabs(a)))));	3580	CHECK(isIdentical(compileAndRun<int32_t>(proc, &a), bitwise_cast<int32_t>(static_cast<float>(fabs(a)))));
3573	}	3581	}
Lines 3581-3587 void testAbsAbsArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec215
3581	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	3589	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
3582	Value* firstAbs = root->appendNew<Value>(proc, Abs, Origin(), argument);	3590	Value* firstAbs = root->appendNew<Value>(proc, Abs, Origin(), argument);
3583	Value* secondAbs = root->appendNew<Value>(proc, Abs, Origin(), firstAbs);	3591	Value* secondAbs = root->appendNew<Value>(proc, Abs, Origin(), firstAbs);
3584	root->appendNew<ControlValue>(proc, Return, Origin(), secondAbs);	3592	root->appendNewControlValue(proc, Return, Origin(), secondAbs);
3585		3593
3586	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), static_cast<float>(fabs(a))));	3594	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), static_cast<float>(fabs(a))));
3587	}	3595	}
Lines 3594-3600 void testAbsBitwiseCastArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec216
3594	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	3602	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
3595	Value* argumentAsfloat = root->appendNew<Value>(proc, BitwiseCast, Origin(), argumentAsInt32);	3603	Value* argumentAsfloat = root->appendNew<Value>(proc, BitwiseCast, Origin(), argumentAsInt32);
3596	Value* absValue = root->appendNew<Value>(proc, Abs, Origin(), argumentAsfloat);	3604	Value* absValue = root->appendNew<Value>(proc, Abs, Origin(), argumentAsfloat);
3597	root->appendNew<ControlValue>(proc, Return, Origin(), absValue);	3605	root->appendNewControlValue(proc, Return, Origin(), absValue);
3598		3606
3599	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), static_cast<float>(fabs(a))));	3607	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), static_cast<float>(fabs(a))));
3600	}	3608	}
Lines 3609-3615 void testBitwiseCastAbsBitwiseCastArg(fl Source/JavaScriptCore/b3/testb3.cpp_sec217
3609	Value* absValue = root->appendNew<Value>(proc, Abs, Origin(), argumentAsfloat);	3617	Value* absValue = root->appendNew<Value>(proc, Abs, Origin(), argumentAsfloat);
3610	Value* resultAsInt64 = root->appendNew<Value>(proc, BitwiseCast, Origin(), absValue);	3618	Value* resultAsInt64 = root->appendNew<Value>(proc, BitwiseCast, Origin(), absValue);
3611		3619
3612	root->appendNew<ControlValue>(proc, Return, Origin(), resultAsInt64);	3620	root->appendNewControlValue(proc, Return, Origin(), resultAsInt64);
3613		3621
3614	int32_t expectedResult = bitwise_cast<int32_t>(static_cast<float>(fabs(a)));	3622	int32_t expectedResult = bitwise_cast<int32_t>(static_cast<float>(fabs(a)));
3615	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), expectedResult));	3623	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), expectedResult));
Lines 3626-3632 void testAbsArgWithUselessDoubleConversi Source/JavaScriptCore/b3/testb3.cpp_sec218
3626	Value* result = root->appendNew<Value>(proc, Abs, Origin(), asDouble);	3634	Value* result = root->appendNew<Value>(proc, Abs, Origin(), asDouble);
3627	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	3635	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
3628	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	3636	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
3629	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3637	root->appendNewControlValue(proc, Return, Origin(), result32);
3630		3638
3631	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fabs(a)))));	3639	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(fabs(a)))));
3632	}	3640	}
Lines 3644-3650 void testAbsArgWithEffectfulDoubleConver Source/JavaScriptCore/b3/testb3.cpp_sec219
3644	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	3652	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
3645	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	3653	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
3646	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);	3654	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);
3647	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3655	root->appendNewControlValue(proc, Return, Origin(), result32);
3648		3656
3649	double effect = 0;	3657	double effect = 0;
3650	int32_t resultValue = compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), &effect);	3658	int32_t resultValue = compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), &effect);
Lines 3656-3662 void testCeilArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec220
3656	{	3664	{
3657	Procedure proc;	3665	Procedure proc;
3658	BasicBlock* root = proc.addBlock();	3666	BasicBlock* root = proc.addBlock();
3659	root->appendNew<ControlValue>(	3667	root->appendNewControlValue(
3660	proc, Return, Origin(),	3668	proc, Return, Origin(),
3661	root->appendNew<Value>(	3669	root->appendNew<Value>(
3662	proc, Ceil, Origin(),	3670	proc, Ceil, Origin(),
Lines 3670-3676 void testCeilImm(double a) Source/JavaScriptCore/b3/testb3.cpp_sec221
3670	Procedure proc;	3678	Procedure proc;
3671	BasicBlock* root = proc.addBlock();	3679	BasicBlock* root = proc.addBlock();
3672	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	3680	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
3673	root->appendNew<ControlValue>(	3681	root->appendNewControlValue(
3674	proc, Return, Origin(),	3682	proc, Return, Origin(),
3675	root->appendNew<Value>(proc, Ceil, Origin(), argument));	3683	root->appendNew<Value>(proc, Ceil, Origin(), argument));
3676		3684
Lines 3683-3689 void testCeilMem(double a) Source/JavaScriptCore/b3/testb3.cpp_sec222
3683	BasicBlock* root = proc.addBlock();	3691	BasicBlock* root = proc.addBlock();
3684	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	3692	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
3685	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);	3693	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);
3686	root->appendNew<ControlValue>(	3694	root->appendNewControlValue(
3687	proc, Return, Origin(),	3695	proc, Return, Origin(),
3688	root->appendNew<Value>(proc, Ceil, Origin(), loadDouble));	3696	root->appendNew<Value>(proc, Ceil, Origin(), loadDouble));
3689		3697
Lines 3697-3703 void testCeilCeilArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec223
3697	Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(),	3705	Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(),
3698	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));	3706	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));
3699	Value* secondCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstCeil);	3707	Value* secondCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstCeil);
3700	root->appendNew<ControlValue>(proc, Return, Origin(), secondCeil);	3708	root->appendNewControlValue(proc, Return, Origin(), secondCeil);
3701		3709
3702	CHECK(isIdentical(compileAndRun<double>(proc, a), ceil(a)));	3710	CHECK(isIdentical(compileAndRun<double>(proc, a), ceil(a)));
3703	}	3711	}
Lines 3709-3715 void testFloorCeilArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec224
3709	Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(),	3717	Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(),
3710	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));	3718	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));
3711	Value* wrappingFloor = root->appendNew<Value>(proc, Floor, Origin(), firstCeil);	3719	Value* wrappingFloor = root->appendNew<Value>(proc, Floor, Origin(), firstCeil);
3712	root->appendNew<ControlValue>(proc, Return, Origin(), wrappingFloor);	3720	root->appendNewControlValue(proc, Return, Origin(), wrappingFloor);
3713		3721
3714	CHECK(isIdentical(compileAndRun<double>(proc, a), ceil(a)));	3722	CHECK(isIdentical(compileAndRun<double>(proc, a), ceil(a)));
3715	}	3723	}
Lines 3721-3727 void testCeilIToD64(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec225
3721	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	3729	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
3722	Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);	3730	Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);
3723		3731
3724	root->appendNew<ControlValue>(	3732	root->appendNewControlValue(
3725	proc, Return, Origin(),	3733	proc, Return, Origin(),
3726	root->appendNew<Value>(proc, Ceil, Origin(), argumentAsDouble));	3734	root->appendNew<Value>(proc, Ceil, Origin(), argumentAsDouble));
3727		3735
Lines 3736-3742 void testCeilIToD32(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec226
3736	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	3744	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
3737	Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);	3745	Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);
3738		3746
3739	root->appendNew<ControlValue>(	3747	root->appendNewControlValue(
3740	proc, Return, Origin(),	3748	proc, Return, Origin(),
3741	root->appendNew<Value>(proc, Ceil, Origin(), argumentAsDouble));	3749	root->appendNew<Value>(proc, Ceil, Origin(), argumentAsDouble));
3742		3750
Lines 3752-3758 void testCeilArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec227
3752	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	3760	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
3753	Value* result = root->appendNew<Value>(proc, Ceil, Origin(), argument);	3761	Value* result = root->appendNew<Value>(proc, Ceil, Origin(), argument);
3754	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	3762	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
3755	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3763	root->appendNewControlValue(proc, Return, Origin(), result32);
3756		3764
3757	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(ceilf(a))));	3765	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(ceilf(a))));
3758	}	3766	}
Lines 3764-3770 void testCeilImm(float a) Source/JavaScriptCore/b3/testb3.cpp_sec228
3764	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), a);	3772	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), a);
3765	Value* result = root->appendNew<Value>(proc, Ceil, Origin(), argument);	3773	Value* result = root->appendNew<Value>(proc, Ceil, Origin(), argument);
3766	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	3774	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
3767	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3775	root->appendNewControlValue(proc, Return, Origin(), result32);
3768		3776
3769	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(ceilf(a))));	3777	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(ceilf(a))));
3770	}	3778	}
Lines 3777-3783 void testCeilMem(float a) Source/JavaScriptCore/b3/testb3.cpp_sec229
3777	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);	3785	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);
3778	Value* result = root->appendNew<Value>(proc, Ceil, Origin(), loadFloat);	3786	Value* result = root->appendNew<Value>(proc, Ceil, Origin(), loadFloat);
3779	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	3787	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
3780	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3788	root->appendNewControlValue(proc, Return, Origin(), result32);
3781		3789
3782	CHECK(isIdentical(compileAndRun<int32_t>(proc, &a), bitwise_cast<int32_t>(ceilf(a))));	3790	CHECK(isIdentical(compileAndRun<int32_t>(proc, &a), bitwise_cast<int32_t>(ceilf(a))));
3783	}	3791	}
Lines 3791-3797 void testCeilCeilArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec230
3791	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	3799	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
3792	Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(), argument);	3800	Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(), argument);
3793	Value* secondCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstCeil);	3801	Value* secondCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstCeil);
3794	root->appendNew<ControlValue>(proc, Return, Origin(), secondCeil);	3802	root->appendNewControlValue(proc, Return, Origin(), secondCeil);
3795		3803
3796	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), ceilf(a)));	3804	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), ceilf(a)));
3797	}	3805	}
Lines 3805-3811 void testFloorCeilArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec231
3805	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	3813	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
3806	Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(), argument);	3814	Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(), argument);
3807	Value* wrappingFloor = root->appendNew<Value>(proc, Floor, Origin(), firstCeil);	3815	Value* wrappingFloor = root->appendNew<Value>(proc, Floor, Origin(), firstCeil);
3808	root->appendNew<ControlValue>(proc, Return, Origin(), wrappingFloor);	3816	root->appendNewControlValue(proc, Return, Origin(), wrappingFloor);
3809		3817
3810	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), ceilf(a)));	3818	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), ceilf(a)));
3811	}	3819	}
Lines 3821-3827 void testCeilArgWithUselessDoubleConvers Source/JavaScriptCore/b3/testb3.cpp_sec232
3821	Value* result = root->appendNew<Value>(proc, Ceil, Origin(), asDouble);	3829	Value* result = root->appendNew<Value>(proc, Ceil, Origin(), asDouble);
3822	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	3830	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
3823	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	3831	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
3824	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3832	root->appendNewControlValue(proc, Return, Origin(), result32);
3825		3833
3826	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(ceilf(a))));	3834	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(ceilf(a))));
3827	}	3835	}
Lines 3839-3845 void testCeilArgWithEffectfulDoubleConve Source/JavaScriptCore/b3/testb3.cpp_sec233
3839	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	3847	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
3840	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	3848	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
3841	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);	3849	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);
3842	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3850	root->appendNewControlValue(proc, Return, Origin(), result32);
3843		3851
3844	double effect = 0;	3852	double effect = 0;
3845	int32_t resultValue = compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), &effect);	3853	int32_t resultValue = compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), &effect);
Lines 3851-3857 void testFloorArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec234
3851	{	3859	{
3852	Procedure proc;	3860	Procedure proc;
3853	BasicBlock* root = proc.addBlock();	3861	BasicBlock* root = proc.addBlock();
3854	root->appendNew<ControlValue>(	3862	root->appendNewControlValue(
3855	proc, Return, Origin(),	3863	proc, Return, Origin(),
3856	root->appendNew<Value>(	3864	root->appendNew<Value>(
3857	proc, Floor, Origin(),	3865	proc, Floor, Origin(),
Lines 3865-3871 void testFloorImm(double a) Source/JavaScriptCore/b3/testb3.cpp_sec235
3865	Procedure proc;	3873	Procedure proc;
3866	BasicBlock* root = proc.addBlock();	3874	BasicBlock* root = proc.addBlock();
3867	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	3875	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
3868	root->appendNew<ControlValue>(	3876	root->appendNewControlValue(
3869	proc, Return, Origin(),	3877	proc, Return, Origin(),
3870	root->appendNew<Value>(proc, Floor, Origin(), argument));	3878	root->appendNew<Value>(proc, Floor, Origin(), argument));
3871		3879
Lines 3878-3884 void testFloorMem(double a) Source/JavaScriptCore/b3/testb3.cpp_sec236
3878	BasicBlock* root = proc.addBlock();	3886	BasicBlock* root = proc.addBlock();
3879	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	3887	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
3880	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);	3888	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);
3881	root->appendNew<ControlValue>(	3889	root->appendNewControlValue(
3882	proc, Return, Origin(),	3890	proc, Return, Origin(),
3883	root->appendNew<Value>(proc, Floor, Origin(), loadDouble));	3891	root->appendNew<Value>(proc, Floor, Origin(), loadDouble));
3884		3892
Lines 3892-3898 void testFloorFloorArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec237
3892	Value* firstFloor = root->appendNew<Value>(proc, Floor, Origin(),	3900	Value* firstFloor = root->appendNew<Value>(proc, Floor, Origin(),
3893	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));	3901	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));
3894	Value* secondFloor = root->appendNew<Value>(proc, Floor, Origin(), firstFloor);	3902	Value* secondFloor = root->appendNew<Value>(proc, Floor, Origin(), firstFloor);
3895	root->appendNew<ControlValue>(proc, Return, Origin(), secondFloor);	3903	root->appendNewControlValue(proc, Return, Origin(), secondFloor);
3896		3904
3897	CHECK(isIdentical(compileAndRun<double>(proc, a), floor(a)));	3905	CHECK(isIdentical(compileAndRun<double>(proc, a), floor(a)));
3898	}	3906	}
Lines 3904-3910 void testCeilFloorArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec238
3904	Value* firstFloor = root->appendNew<Value>(proc, Floor, Origin(),	3912	Value* firstFloor = root->appendNew<Value>(proc, Floor, Origin(),
3905	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));	3913	root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));
3906	Value* wrappingCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstFloor);	3914	Value* wrappingCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstFloor);
3907	root->appendNew<ControlValue>(proc, Return, Origin(), wrappingCeil);	3915	root->appendNewControlValue(proc, Return, Origin(), wrappingCeil);
3908		3916
3909	CHECK(isIdentical(compileAndRun<double>(proc, a), floor(a)));	3917	CHECK(isIdentical(compileAndRun<double>(proc, a), floor(a)));
3910	}	3918	}
Lines 3916-3922 void testFloorIToD64(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec239
3916	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	3924	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
3917	Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);	3925	Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);
3918		3926
3919	root->appendNew<ControlValue>(	3927	root->appendNewControlValue(
3920	proc, Return, Origin(),	3928	proc, Return, Origin(),
3921	root->appendNew<Value>(proc, Floor, Origin(), argumentAsDouble));	3929	root->appendNew<Value>(proc, Floor, Origin(), argumentAsDouble));
3922		3930
Lines 3931-3937 void testFloorIToD32(int64_t a) Source/JavaScriptCore/b3/testb3.cpp_sec240
3931	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	3939	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
3932	Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);	3940	Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);
3933		3941
3934	root->appendNew<ControlValue>(	3942	root->appendNewControlValue(
3935	proc, Return, Origin(),	3943	proc, Return, Origin(),
3936	root->appendNew<Value>(proc, Floor, Origin(), argumentAsDouble));	3944	root->appendNew<Value>(proc, Floor, Origin(), argumentAsDouble));
3937		3945
Lines 3947-3953 void testFloorArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec241
3947	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	3955	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
3948	Value* result = root->appendNew<Value>(proc, Floor, Origin(), argument);	3956	Value* result = root->appendNew<Value>(proc, Floor, Origin(), argument);
3949	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	3957	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
3950	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3958	root->appendNewControlValue(proc, Return, Origin(), result32);
3951		3959
3952	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(floorf(a))));	3960	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(floorf(a))));
3953	}	3961	}
Lines 3959-3965 void testFloorImm(float a) Source/JavaScriptCore/b3/testb3.cpp_sec242
3959	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), a);	3967	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), a);
3960	Value* result = root->appendNew<Value>(proc, Floor, Origin(), argument);	3968	Value* result = root->appendNew<Value>(proc, Floor, Origin(), argument);
3961	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	3969	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
3962	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3970	root->appendNewControlValue(proc, Return, Origin(), result32);
3963		3971
3964	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(floorf(a))));	3972	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(floorf(a))));
3965	}	3973	}
Lines 3972-3978 void testFloorMem(float a) Source/JavaScriptCore/b3/testb3.cpp_sec243
3972	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);	3980	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);
3973	Value* result = root->appendNew<Value>(proc, Floor, Origin(), loadFloat);	3981	Value* result = root->appendNew<Value>(proc, Floor, Origin(), loadFloat);
3974	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	3982	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
3975	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	3983	root->appendNewControlValue(proc, Return, Origin(), result32);
3976		3984
3977	CHECK(isIdentical(compileAndRun<int32_t>(proc, &a), bitwise_cast<int32_t>(floorf(a))));	3985	CHECK(isIdentical(compileAndRun<int32_t>(proc, &a), bitwise_cast<int32_t>(floorf(a))));
3978	}	3986	}
Lines 3986-3992 void testFloorFloorArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec244
3986	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	3994	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
3987	Value* firstFloor = root->appendNew<Value>(proc, Floor, Origin(), argument);	3995	Value* firstFloor = root->appendNew<Value>(proc, Floor, Origin(), argument);
3988	Value* secondFloor = root->appendNew<Value>(proc, Floor, Origin(), firstFloor);	3996	Value* secondFloor = root->appendNew<Value>(proc, Floor, Origin(), firstFloor);
3989	root->appendNew<ControlValue>(proc, Return, Origin(), secondFloor);	3997	root->appendNewControlValue(proc, Return, Origin(), secondFloor);
3990		3998
3991	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), floorf(a)));	3999	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), floorf(a)));
3992	}	4000	}
Lines 4000-4006 void testCeilFloorArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec245
4000	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	4008	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
4001	Value* firstFloor = root->appendNew<Value>(proc, Floor, Origin(), argument);	4009	Value* firstFloor = root->appendNew<Value>(proc, Floor, Origin(), argument);
4002	Value* wrappingCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstFloor);	4010	Value* wrappingCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstFloor);
4003	root->appendNew<ControlValue>(proc, Return, Origin(), wrappingCeil);	4011	root->appendNewControlValue(proc, Return, Origin(), wrappingCeil);
4004		4012
4005	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), floorf(a)));	4013	CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), floorf(a)));
4006	}	4014	}
Lines 4016-4022 void testFloorArgWithUselessDoubleConver Source/JavaScriptCore/b3/testb3.cpp_sec246
4016	Value* result = root->appendNew<Value>(proc, Floor, Origin(), asDouble);	4024	Value* result = root->appendNew<Value>(proc, Floor, Origin(), asDouble);
4017	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	4025	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
4018	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	4026	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
4019	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	4027	root->appendNewControlValue(proc, Return, Origin(), result32);
4020		4028
4021	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(floorf(a))));	4029	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(floorf(a))));
4022	}	4030	}
Lines 4034-4040 void testFloorArgWithEffectfulDoubleConv Source/JavaScriptCore/b3/testb3.cpp_sec247
4034	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	4042	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
4035	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	4043	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
4036	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);	4044	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);
4037	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	4045	root->appendNewControlValue(proc, Return, Origin(), result32);
4038		4046
4039	double effect = 0;	4047	double effect = 0;
4040	int32_t resultValue = compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), &effect);	4048	int32_t resultValue = compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), &effect);
Lines 4046-4052 void testSqrtArg(double a) Source/JavaScriptCore/b3/testb3.cpp_sec248
4046	{	4054	{
4047	Procedure proc;	4055	Procedure proc;
4048	BasicBlock* root = proc.addBlock();	4056	BasicBlock* root = proc.addBlock();
4049	root->appendNew<ControlValue>(	4057	root->appendNewControlValue(
4050	proc, Return, Origin(),	4058	proc, Return, Origin(),
4051	root->appendNew<Value>(	4059	root->appendNew<Value>(
4052	proc, Sqrt, Origin(),	4060	proc, Sqrt, Origin(),
Lines 4060-4066 void testSqrtImm(double a) Source/JavaScriptCore/b3/testb3.cpp_sec249
4060	Procedure proc;	4068	Procedure proc;
4061	BasicBlock* root = proc.addBlock();	4069	BasicBlock* root = proc.addBlock();
4062	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	4070	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
4063	root->appendNew<ControlValue>(	4071	root->appendNewControlValue(
4064	proc, Return, Origin(),	4072	proc, Return, Origin(),
4065	root->appendNew<Value>(proc, Sqrt, Origin(), argument));	4073	root->appendNew<Value>(proc, Sqrt, Origin(), argument));
4066		4074
Lines 4073-4079 void testSqrtMem(double a) Source/JavaScriptCore/b3/testb3.cpp_sec250
4073	BasicBlock* root = proc.addBlock();	4081	BasicBlock* root = proc.addBlock();
4074	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4082	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4075	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);	4083	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);
4076	root->appendNew<ControlValue>(	4084	root->appendNewControlValue(
4077	proc, Return, Origin(),	4085	proc, Return, Origin(),
4078	root->appendNew<Value>(proc, Sqrt, Origin(), loadDouble));	4086	root->appendNew<Value>(proc, Sqrt, Origin(), loadDouble));
4079		4087
Lines 4089-4095 void testSqrtArg(float a) Source/JavaScriptCore/b3/testb3.cpp_sec251
4089	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	4097	Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
4090	Value* result = root->appendNew<Value>(proc, Sqrt, Origin(), argument);	4098	Value* result = root->appendNew<Value>(proc, Sqrt, Origin(), argument);
4091	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	4099	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
4092	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	4100	root->appendNewControlValue(proc, Return, Origin(), result32);
4093		4101
4094	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(sqrt(a)))));	4102	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(sqrt(a)))));
4095	}	4103	}
Lines 4101-4107 void testSqrtImm(float a) Source/JavaScriptCore/b3/testb3.cpp_sec252
4101	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), a);	4109	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), a);
4102	Value* result = root->appendNew<Value>(proc, Sqrt, Origin(), argument);	4110	Value* result = root->appendNew<Value>(proc, Sqrt, Origin(), argument);
4103	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	4111	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
4104	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	4112	root->appendNewControlValue(proc, Return, Origin(), result32);
4105		4113
4106	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(sqrt(a)))));	4114	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(sqrt(a)))));
4107	}	4115	}
Lines 4114-4120 void testSqrtMem(float a) Source/JavaScriptCore/b3/testb3.cpp_sec253
4114	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);	4122	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);
4115	Value* result = root->appendNew<Value>(proc, Sqrt, Origin(), loadFloat);	4123	Value* result = root->appendNew<Value>(proc, Sqrt, Origin(), loadFloat);
4116	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);	4124	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
4117	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	4125	root->appendNewControlValue(proc, Return, Origin(), result32);
4118		4126
4119	CHECK(isIdentical(compileAndRun<int32_t>(proc, &a), bitwise_cast<int32_t>(static_cast<float>(sqrt(a)))));	4127	CHECK(isIdentical(compileAndRun<int32_t>(proc, &a), bitwise_cast<int32_t>(static_cast<float>(sqrt(a)))));
4120	}	4128	}
Lines 4130-4136 void testSqrtArgWithUselessDoubleConvers Source/JavaScriptCore/b3/testb3.cpp_sec254
4130	Value* result = root->appendNew<Value>(proc, Sqrt, Origin(), asDouble);	4138	Value* result = root->appendNew<Value>(proc, Sqrt, Origin(), asDouble);
4131	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);	4139	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
4132	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	4140	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
4133	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	4141	root->appendNewControlValue(proc, Return, Origin(), result32);
4134		4142
4135	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(sqrt(a)))));	4143	CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(static_cast<float>(sqrt(a)))));
4136	}	4144	}
Lines 4148-4154 void testSqrtArgWithEffectfulDoubleConve Source/JavaScriptCore/b3/testb3.cpp_sec255
4148	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);	4156	Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
4149	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	4157	Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
4150	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);	4158	root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);
4151	root->appendNew<ControlValue>(proc, Return, Origin(), result32);	4159	root->appendNewControlValue(proc, Return, Origin(), result32);
4152		4160
4153	double effect = 0;	4161	double effect = 0;
4154	int32_t resultValue = compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), &effect);	4162	int32_t resultValue = compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), &effect);
Lines 4172-4178 void testCompareTwoFloatToDouble(float a Source/JavaScriptCore/b3/testb3.cpp_sec256
4172	Value* arg2AsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), arg2Float);	4180	Value* arg2AsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), arg2Float);
4173	Value* equal = root->appendNew<Value>(proc, Equal, Origin(), arg1AsDouble, arg2AsDouble);	4181	Value* equal = root->appendNew<Value>(proc, Equal, Origin(), arg1AsDouble, arg2AsDouble);
4174		4182
4175	root->appendNew<ControlValue>(proc, Return, Origin(), equal);	4183	root->appendNewControlValue(proc, Return, Origin(), equal);
4176		4184
4177	CHECK(compileAndRun<int64_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)) == (a == b));	4185	CHECK(compileAndRun<int64_t>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)) == (a == b));
4178	}	4186	}
Lines 4190-4196 void testCompareOneFloatToDouble(float a Source/JavaScriptCore/b3/testb3.cpp_sec257
4190	Value* arg2AsDouble = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	4198	Value* arg2AsDouble = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
4191	Value* equal = root->appendNew<Value>(proc, Equal, Origin(), arg1AsDouble, arg2AsDouble);	4199	Value* equal = root->appendNew<Value>(proc, Equal, Origin(), arg1AsDouble, arg2AsDouble);
4192		4200
4193	root->appendNew<ControlValue>(proc, Return, Origin(), equal);	4201	root->appendNewControlValue(proc, Return, Origin(), equal);
4194		4202
4195	CHECK(compileAndRun<int64_t>(proc, bitwise_cast<int32_t>(a), b) == (a == b));	4203	CHECK(compileAndRun<int64_t>(proc, bitwise_cast<int32_t>(a), b) == (a == b));
4196	}	4204	}
Lines 4214-4236 void testCompareFloatToDoubleThroughPhi( Source/JavaScriptCore/b3/testb3.cpp_sec258
4214	Value* arg2AsFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), arg2AsDouble);	4222	Value* arg2AsFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), arg2AsDouble);
4215	Value* arg2AsFRoundedDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), arg2AsFloat);	4223	Value* arg2AsFRoundedDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), arg2AsFloat);
4216		4224
4217	root->appendNew<ControlValue>(	4225	root->appendNewControlValue(
4218	proc, Branch, Origin(),	4226	proc, Branch, Origin(),
4219	condition,	4227	condition,
4220	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	4228	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
4221		4229
4222	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), arg1AsDouble);	4230	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), arg1AsDouble);
4223	thenCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4231	thenCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4224		4232
4225	Value* elseConst = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), 0.);	4233	Value* elseConst = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), 0.);
4226	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), elseConst);	4234	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), elseConst);
4227	elseCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4235	elseCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4228		4236
4229	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());	4237	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());
4230	thenValue->setPhi(doubleInput);	4238	thenValue->setPhi(doubleInput);
4231	elseValue->setPhi(doubleInput);	4239	elseValue->setPhi(doubleInput);
4232	Value* equal = tail->appendNew<Value>(proc, Equal, Origin(), doubleInput, arg2AsFRoundedDouble);	4240	Value* equal = tail->appendNew<Value>(proc, Equal, Origin(), doubleInput, arg2AsFRoundedDouble);
4233	tail->appendNew<ControlValue>(proc, Return, Origin(), equal);	4241	tail->appendNewControlValue(proc, Return, Origin(), equal);
4234		4242
4235	auto code = compile(proc);	4243	auto code = compile(proc);
4236	int32_t integerA = bitwise_cast<int32_t>(a);	4244	int32_t integerA = bitwise_cast<int32_t>(a);
Lines 4261-4267 void testDoubleToFloatThroughPhi(float v Source/JavaScriptCore/b3/testb3.cpp_sec259
4261	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	4269	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
4262	Value* argAsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);	4270	Value* argAsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);
4263		4271
4264	root->appendNew<ControlValue>(	4272	root->appendNewControlValue(
4265	proc, Branch, Origin(),	4273	proc, Branch, Origin(),
4266	condition,	4274	condition,
4267	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	4275	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
Lines 4269-4285 void testDoubleToFloatThroughPhi(float v Source/JavaScriptCore/b3/testb3.cpp_sec260
4269	Value* postitiveConst = thenCase->appendNew<ConstDoubleValue>(proc, Origin(), 42.5f);	4277	Value* postitiveConst = thenCase->appendNew<ConstDoubleValue>(proc, Origin(), 42.5f);
4270	Value* thenAdd = thenCase->appendNew<Value>(proc, Add, Origin(), argAsDouble, postitiveConst);	4278	Value* thenAdd = thenCase->appendNew<Value>(proc, Add, Origin(), argAsDouble, postitiveConst);
4271	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), thenAdd);	4279	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), thenAdd);
4272	thenCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4280	thenCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4273		4281
4274	Value* elseConst = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), M_PI);	4282	Value* elseConst = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), M_PI);
4275	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), elseConst);	4283	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), elseConst);
4276	elseCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4284	elseCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4277		4285
4278	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());	4286	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());
4279	thenValue->setPhi(doubleInput);	4287	thenValue->setPhi(doubleInput);
4280	elseValue->setPhi(doubleInput);	4288	elseValue->setPhi(doubleInput);
4281	Value* floatResult = tail->appendNew<Value>(proc, DoubleToFloat, Origin(), doubleInput);	4289	Value* floatResult = tail->appendNew<Value>(proc, DoubleToFloat, Origin(), doubleInput);
4282	tail->appendNew<ControlValue>(proc, Return, Origin(), floatResult);	4290	tail->appendNewControlValue(proc, Return, Origin(), floatResult);
4283		4291
4284	auto code = compile(proc);	4292	auto code = compile(proc);
4285	CHECK(isIdentical(invoke<float>(*code, 1, bitwise_cast<int32_t>(value)), value + 42.5f));	4293	CHECK(isIdentical(invoke<float>(*code, 1, bitwise_cast<int32_t>(value)), value + 42.5f));
Lines 4299-4316 void testDoubleProducerPhiToFloatConvers Source/JavaScriptCore/b3/testb3.cpp_sec261
4299	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	4307	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
4300	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	4308	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
4301		4309
4302	root->appendNew<ControlValue>(	4310	root->appendNewControlValue(
4303	proc, Branch, Origin(),	4311	proc, Branch, Origin(),
4304	condition,	4312	condition,
4305	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	4313	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
4306		4314
4307	Value* asDouble = thenCase->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);	4315	Value* asDouble = thenCase->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);
4308	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), asDouble);	4316	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), asDouble);
4309	thenCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4317	thenCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4310		4318
4311	Value* constDouble = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), 42.5);	4319	Value* constDouble = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), 42.5);
4312	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), constDouble);	4320	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), constDouble);
4313	elseCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4321	elseCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4314		4322
4315	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());	4323	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());
4316	thenValue->setPhi(doubleInput);	4324	thenValue->setPhi(doubleInput);
Lines 4319-4325 void testDoubleProducerPhiToFloatConvers Source/JavaScriptCore/b3/testb3.cpp_sec262
4319	Value* argAsDoubleAgain = tail->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);	4327	Value* argAsDoubleAgain = tail->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);
4320	Value* finalAdd = tail->appendNew<Value>(proc, Add, Origin(), doubleInput, argAsDoubleAgain);	4328	Value* finalAdd = tail->appendNew<Value>(proc, Add, Origin(), doubleInput, argAsDoubleAgain);
4321	Value* floatResult = tail->appendNew<Value>(proc, DoubleToFloat, Origin(), finalAdd);	4329	Value* floatResult = tail->appendNew<Value>(proc, DoubleToFloat, Origin(), finalAdd);
4322	tail->appendNew<ControlValue>(proc, Return, Origin(), floatResult);	4330	tail->appendNewControlValue(proc, Return, Origin(), floatResult);
4323		4331
4324	auto code = compile(proc);	4332	auto code = compile(proc);
4325	CHECK(isIdentical(invoke<float>(*code, 1, bitwise_cast<int32_t>(value)), value + value));	4333	CHECK(isIdentical(invoke<float>(*code, 1, bitwise_cast<int32_t>(value)), value + value));
Lines 4341-4358 void testDoubleProducerPhiToFloatConvers Source/JavaScriptCore/b3/testb3.cpp_sec263
4341	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	4349	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
4342	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	4350	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
4343		4351
4344	root->appendNew<ControlValue>(	4352	root->appendNewControlValue(
4345	proc, Branch, Origin(),	4353	proc, Branch, Origin(),
4346	condition,	4354	condition,
4347	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	4355	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
4348		4356
4349	Value* asDouble = thenCase->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);	4357	Value* asDouble = thenCase->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);
4350	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), asDouble);	4358	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), asDouble);
4351	thenCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4359	thenCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4352		4360
4353	Value* constDouble = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), 42.5);	4361	Value* constDouble = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), 42.5);
4354	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), constDouble);	4362	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), constDouble);
4355	elseCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4363	elseCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4356		4364
4357	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());	4365	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());
4358	thenValue->setPhi(doubleInput);	4366	thenValue->setPhi(doubleInput);
Lines 4368-4374 void testDoubleProducerPhiToFloatConvers Source/JavaScriptCore/b3/testb3.cpp_sec264
4368	// This one cannot be eliminated	4376	// This one cannot be eliminated
4369	Value* doubleAdd = tail->appendNew<Value>(proc, Add, Origin(), doubleInput, doubleResult);	4377	Value* doubleAdd = tail->appendNew<Value>(proc, Add, Origin(), doubleInput, doubleResult);
4370		4378
4371	tail->appendNew<ControlValue>(proc, Return, Origin(), doubleAdd);	4379	tail->appendNewControlValue(proc, Return, Origin(), doubleAdd);
4372		4380
4373	auto code = compile(proc);	4381	auto code = compile(proc);
4374	CHECK(isIdentical(invoke<double>(*code, 1, bitwise_cast<int32_t>(value)), (value + value) + static_cast<double>(value)));	4382	CHECK(isIdentical(invoke<double>(*code, 1, bitwise_cast<int32_t>(value)), (value + value) + static_cast<double>(value)));
Lines 4388-4405 void testDoubleProducerPhiWithNonFloatCo Source/JavaScriptCore/b3/testb3.cpp_sec265
4388	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	4396	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
4389	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	4397	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
4390		4398
4391	root->appendNew<ControlValue>(	4399	root->appendNewControlValue(
4392	proc, Branch, Origin(),	4400	proc, Branch, Origin(),
4393	condition,	4401	condition,
4394	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	4402	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
4395		4403
4396	Value* asDouble = thenCase->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);	4404	Value* asDouble = thenCase->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);
4397	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), asDouble);	4405	UpsilonValue* thenValue = thenCase->appendNew<UpsilonValue>(proc, Origin(), asDouble);
4398	thenCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4406	thenCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4399		4407
4400	Value* constDouble = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), constValue);	4408	Value* constDouble = elseCase->appendNew<ConstDoubleValue>(proc, Origin(), constValue);
4401	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), constDouble);	4409	UpsilonValue* elseValue = elseCase->appendNew<UpsilonValue>(proc, Origin(), constDouble);
4402	elseCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	4410	elseCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
4403		4411
4404	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());	4412	Value* doubleInput = tail->appendNew<Value>(proc, Phi, Double, Origin());
4405	thenValue->setPhi(doubleInput);	4413	thenValue->setPhi(doubleInput);
Lines 4408-4414 void testDoubleProducerPhiWithNonFloatCo Source/JavaScriptCore/b3/testb3.cpp_sec266
4408	Value* argAsDoubleAgain = tail->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);	4416	Value* argAsDoubleAgain = tail->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);
4409	Value* finalAdd = tail->appendNew<Value>(proc, Add, Origin(), doubleInput, argAsDoubleAgain);	4417	Value* finalAdd = tail->appendNew<Value>(proc, Add, Origin(), doubleInput, argAsDoubleAgain);
4410	Value* floatResult = tail->appendNew<Value>(proc, DoubleToFloat, Origin(), finalAdd);	4418	Value* floatResult = tail->appendNew<Value>(proc, DoubleToFloat, Origin(), finalAdd);
4411	tail->appendNew<ControlValue>(proc, Return, Origin(), floatResult);	4419	tail->appendNewControlValue(proc, Return, Origin(), floatResult);
4412		4420
4413	auto code = compile(proc);	4421	auto code = compile(proc);
4414	CHECK(isIdentical(invoke<float>(*code, 1, bitwise_cast<int32_t>(value)), value + value));	4422	CHECK(isIdentical(invoke<float>(*code, 1, bitwise_cast<int32_t>(value)), value + value));
Lines 4421-4427 void testDoubleArgToInt64BitwiseCast(dou Source/JavaScriptCore/b3/testb3.cpp_sec267
4421	BasicBlock* root = proc.addBlock();	4429	BasicBlock* root = proc.addBlock();
4422	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	4430	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
4423		4431
4424	root->appendNew<ControlValue>(	4432	root->appendNewControlValue(
4425	proc, Return, Origin(),	4433	proc, Return, Origin(),
4426	root->appendNew<Value>(	4434	root->appendNew<Value>(
4427	proc, BitwiseCast, Origin(), argument));	4435	proc, BitwiseCast, Origin(), argument));
Lines 4435-4441 void testDoubleImmToInt64BitwiseCast(dou Source/JavaScriptCore/b3/testb3.cpp_sec268
4435	BasicBlock* root = proc.addBlock();	4443	BasicBlock* root = proc.addBlock();
4436	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), value);	4444	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), value);
4437		4445
4438	root->appendNew<ControlValue>(	4446	root->appendNewControlValue(
4439	proc, Return, Origin(),	4447	proc, Return, Origin(),
4440	root->appendNew<Value>(	4448	root->appendNew<Value>(
4441	proc, BitwiseCast, Origin(), argument));	4449	proc, BitwiseCast, Origin(), argument));
Lines 4450-4456 void testTwoBitwiseCastOnDouble(double v Source/JavaScriptCore/b3/testb3.cpp_sec269
4450	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	4458	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
4451	Value* first = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument);	4459	Value* first = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument);
4452	Value* second = root->appendNew<Value>(proc, BitwiseCast, Origin(), first);	4460	Value* second = root->appendNew<Value>(proc, BitwiseCast, Origin(), first);
4453	root->appendNew<ControlValue>(proc, Return, Origin(), second);	4461	root->appendNewControlValue(proc, Return, Origin(), second);
4454		4462
4455	CHECK(isIdentical(compileAndRun<double>(proc, value), value));	4463	CHECK(isIdentical(compileAndRun<double>(proc, value), value));
4456	}	4464	}
Lines 4462-4468 void testBitwiseCastOnDoubleInMemory(dou Source/JavaScriptCore/b3/testb3.cpp_sec270
4462	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4470	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4463	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);	4471	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);
4464	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadDouble);	4472	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadDouble);
4465	root->appendNew<ControlValue>(proc, Return, Origin(), cast);	4473	root->appendNewControlValue(proc, Return, Origin(), cast);
4466		4474
4467	CHECK(isIdentical(compileAndRun<int64_t>(proc, &value), bitwise_cast<int64_t>(value)));	4475	CHECK(isIdentical(compileAndRun<int64_t>(proc, &value), bitwise_cast<int64_t>(value)));
4468	}	4476	}
Lines 4479-4485 void testBitwiseCastOnDoubleInMemoryInde Source/JavaScriptCore/b3/testb3.cpp_sec271
4479	Value* address = root->appendNew<Value>(proc, Add, Origin(), base, scaledOffset);	4487	Value* address = root->appendNew<Value>(proc, Add, Origin(), base, scaledOffset);
4480	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);	4488	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);
4481	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadDouble);	4489	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadDouble);
4482	root->appendNew<ControlValue>(proc, Return, Origin(), cast);	4490	root->appendNewControlValue(proc, Return, Origin(), cast);
4483		4491
4484	CHECK(isIdentical(compileAndRun<int64_t>(proc, &value, 0), bitwise_cast<int64_t>(value)));	4492	CHECK(isIdentical(compileAndRun<int64_t>(proc, &value, 0), bitwise_cast<int64_t>(value)));
4485	}	4493	}
Lines 4490-4496 void testInt64BArgToDoubleBitwiseCast(in Source/JavaScriptCore/b3/testb3.cpp_sec272
4490	BasicBlock* root = proc.addBlock();	4498	BasicBlock* root = proc.addBlock();
4491	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4499	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4492		4500
4493	root->appendNew<ControlValue>(	4501	root->appendNewControlValue(
4494	proc, Return, Origin(),	4502	proc, Return, Origin(),
4495	root->appendNew<Value>(	4503	root->appendNew<Value>(
4496	proc, BitwiseCast, Origin(), argument));	4504	proc, BitwiseCast, Origin(), argument));
Lines 4504-4510 void testInt64BImmToDoubleBitwiseCast(in Source/JavaScriptCore/b3/testb3.cpp_sec273
4504	BasicBlock* root = proc.addBlock();	4512	BasicBlock* root = proc.addBlock();
4505	Value* argument = root->appendNew<Const64Value>(proc, Origin(), value);	4513	Value* argument = root->appendNew<Const64Value>(proc, Origin(), value);
4506		4514
4507	root->appendNew<ControlValue>(	4515	root->appendNewControlValue(
4508	proc, Return, Origin(),	4516	proc, Return, Origin(),
4509	root->appendNew<Value>(	4517	root->appendNew<Value>(
4510	proc, BitwiseCast, Origin(), argument));	4518	proc, BitwiseCast, Origin(), argument));
Lines 4519-4525 void testTwoBitwiseCastOnInt64(int64_t v Source/JavaScriptCore/b3/testb3.cpp_sec274
4519	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4527	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4520	Value* first = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument);	4528	Value* first = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument);
4521	Value* second = root->appendNew<Value>(proc, BitwiseCast, Origin(), first);	4529	Value* second = root->appendNew<Value>(proc, BitwiseCast, Origin(), first);
4522	root->appendNew<ControlValue>(proc, Return, Origin(), second);	4530	root->appendNewControlValue(proc, Return, Origin(), second);
4523		4531
4524	CHECK(isIdentical(compileAndRun<int64_t>(proc, value), value));	4532	CHECK(isIdentical(compileAndRun<int64_t>(proc, value), value));
4525	}	4533	}
Lines 4531-4537 void testBitwiseCastOnInt64InMemory(int6 Source/JavaScriptCore/b3/testb3.cpp_sec275
4531	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4539	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4532	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);	4540	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);
4533	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadDouble);	4541	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadDouble);
4534	root->appendNew<ControlValue>(proc, Return, Origin(), cast);	4542	root->appendNewControlValue(proc, Return, Origin(), cast);
4535		4543
4536	CHECK(isIdentical(compileAndRun<double>(proc, &value), bitwise_cast<double>(value)));	4544	CHECK(isIdentical(compileAndRun<double>(proc, &value), bitwise_cast<double>(value)));
4537	}	4545	}
Lines 4548-4554 void testBitwiseCastOnInt64InMemoryIndex Source/JavaScriptCore/b3/testb3.cpp_sec276
4548	Value* address = root->appendNew<Value>(proc, Add, Origin(), base, scaledOffset);	4556	Value* address = root->appendNew<Value>(proc, Add, Origin(), base, scaledOffset);
4549	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);	4557	MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);
4550	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadDouble);	4558	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadDouble);
4551	root->appendNew<ControlValue>(proc, Return, Origin(), cast);	4559	root->appendNewControlValue(proc, Return, Origin(), cast);
4552		4560
4553	CHECK(isIdentical(compileAndRun<double>(proc, &value, 0), bitwise_cast<double>(value)));	4561	CHECK(isIdentical(compileAndRun<double>(proc, &value, 0), bitwise_cast<double>(value)));
4554	}	4562	}
Lines 4559-4565 void testFloatImmToInt32BitwiseCast(floa Source/JavaScriptCore/b3/testb3.cpp_sec277
4559	BasicBlock* root = proc.addBlock();	4567	BasicBlock* root = proc.addBlock();
4560	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), value);	4568	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), value);
4561		4569
4562	root->appendNew<ControlValue>(	4570	root->appendNewControlValue(
4563	proc, Return, Origin(),	4571	proc, Return, Origin(),
4564	root->appendNew<Value>(	4572	root->appendNew<Value>(
4565	proc, BitwiseCast, Origin(), argument));	4573	proc, BitwiseCast, Origin(), argument));
Lines 4574-4580 void testBitwiseCastOnFloatInMemory(floa Source/JavaScriptCore/b3/testb3.cpp_sec278
4574	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4582	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4575	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);	4583	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);
4576	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadFloat);	4584	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadFloat);
4577	root->appendNew<ControlValue>(proc, Return, Origin(), cast);	4585	root->appendNewControlValue(proc, Return, Origin(), cast);
4578		4586
4579	CHECK(isIdentical(compileAndRun<int32_t>(proc, &value), bitwise_cast<int32_t>(value)));	4587	CHECK(isIdentical(compileAndRun<int32_t>(proc, &value), bitwise_cast<int32_t>(value)));
4580	}	4588	}
Lines 4585-4591 void testInt32BArgToFloatBitwiseCast(int Source/JavaScriptCore/b3/testb3.cpp_sec279
4585	BasicBlock* root = proc.addBlock();	4593	BasicBlock* root = proc.addBlock();
4586	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4594	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4587		4595
4588	root->appendNew<ControlValue>(	4596	root->appendNewControlValue(
4589	proc, Return, Origin(),	4597	proc, Return, Origin(),
4590	root->appendNew<Value>(	4598	root->appendNew<Value>(
4591	proc, BitwiseCast, Origin(), argument));	4599	proc, BitwiseCast, Origin(), argument));
Lines 4599-4605 void testInt32BImmToFloatBitwiseCast(int Source/JavaScriptCore/b3/testb3.cpp_sec280
4599	BasicBlock* root = proc.addBlock();	4607	BasicBlock* root = proc.addBlock();
4600	Value* argument = root->appendNew<Const64Value>(proc, Origin(), value);	4608	Value* argument = root->appendNew<Const64Value>(proc, Origin(), value);
4601		4609
4602	root->appendNew<ControlValue>(	4610	root->appendNewControlValue(
4603	proc, Return, Origin(),	4611	proc, Return, Origin(),
4604	root->appendNew<Value>(	4612	root->appendNew<Value>(
4605	proc, BitwiseCast, Origin(), argument));	4613	proc, BitwiseCast, Origin(), argument));
Lines 4614-4620 void testTwoBitwiseCastOnInt32(int32_t v Source/JavaScriptCore/b3/testb3.cpp_sec281
4614	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4622	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4615	Value* first = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument);	4623	Value* first = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument);
4616	Value* second = root->appendNew<Value>(proc, BitwiseCast, Origin(), first);	4624	Value* second = root->appendNew<Value>(proc, BitwiseCast, Origin(), first);
4617	root->appendNew<ControlValue>(proc, Return, Origin(), second);	4625	root->appendNewControlValue(proc, Return, Origin(), second);
4618		4626
4619	CHECK(isIdentical(compileAndRun<int32_t>(proc, value), value));	4627	CHECK(isIdentical(compileAndRun<int32_t>(proc, value), value));
4620	}	4628	}
Lines 4626-4632 void testBitwiseCastOnInt32InMemory(int3 Source/JavaScriptCore/b3/testb3.cpp_sec282
4626	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4634	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4627	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), address);	4635	MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), address);
4628	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadFloat);	4636	Value* cast = root->appendNew<Value>(proc, BitwiseCast, Origin(), loadFloat);
4629	root->appendNew<ControlValue>(proc, Return, Origin(), cast);	4637	root->appendNewControlValue(proc, Return, Origin(), cast);
4630		4638
4631	CHECK(isIdentical(compileAndRun<float>(proc, &value), bitwise_cast<float>(value)));	4639	CHECK(isIdentical(compileAndRun<float>(proc, &value), bitwise_cast<float>(value)));
4632	}	4640	}
Lines 4637-4643 void testConvertDoubleToFloatArg(double Source/JavaScriptCore/b3/testb3.cpp_sec283
4637	BasicBlock* root = proc.addBlock();	4645	BasicBlock* root = proc.addBlock();
4638	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	4646	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
4639	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), argument);	4647	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), argument);
4640	root->appendNew<ControlValue>(proc, Return, Origin(), asFloat);	4648	root->appendNewControlValue(proc, Return, Origin(), asFloat);
4641		4649
4642	CHECK(isIdentical(compileAndRun<float>(proc, value), static_cast<float>(value)));	4650	CHECK(isIdentical(compileAndRun<float>(proc, value), static_cast<float>(value)));
4643	}	4651	}
Lines 4648-4654 void testConvertDoubleToFloatImm(double Source/JavaScriptCore/b3/testb3.cpp_sec284
4648	BasicBlock* root = proc.addBlock();	4656	BasicBlock* root = proc.addBlock();
4649	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), value);	4657	Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), value);
4650	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), argument);	4658	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), argument);
4651	root->appendNew<ControlValue>(proc, Return, Origin(), asFloat);	4659	root->appendNewControlValue(proc, Return, Origin(), asFloat);
4652		4660
4653	CHECK(isIdentical(compileAndRun<float>(proc), static_cast<float>(value)));	4661	CHECK(isIdentical(compileAndRun<float>(proc), static_cast<float>(value)));
4654	}	4662	}
Lines 4660-4666 void testConvertDoubleToFloatMem(double Source/JavaScriptCore/b3/testb3.cpp_sec285
4660	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4668	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4661	MemoryValue* loadedDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);	4669	MemoryValue* loadedDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);
4662	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), loadedDouble);	4670	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), loadedDouble);
4663	root->appendNew<ControlValue>(proc, Return, Origin(), asFloat);	4671	root->appendNewControlValue(proc, Return, Origin(), asFloat);
4664		4672
4665	CHECK(isIdentical(compileAndRun<float>(proc, &value), static_cast<float>(value)));	4673	CHECK(isIdentical(compileAndRun<float>(proc, &value), static_cast<float>(value)));
4666	}	4674	}
Lines 4673-4679 void testConvertFloatToDoubleArg(float v Source/JavaScriptCore/b3/testb3.cpp_sec286
4673	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	4681	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
4674	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);	4682	Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
4675	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);	4683	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);
4676	root->appendNew<ControlValue>(proc, Return, Origin(), asDouble);	4684	root->appendNewControlValue(proc, Return, Origin(), asDouble);
4677		4685
4678	CHECK(isIdentical(compileAndRun<double>(proc, bitwise_cast<int32_t>(value)), static_cast<double>(value)));	4686	CHECK(isIdentical(compileAndRun<double>(proc, bitwise_cast<int32_t>(value)), static_cast<double>(value)));
4679	}	4687	}
Lines 4684-4690 void testConvertFloatToDoubleImm(float v Source/JavaScriptCore/b3/testb3.cpp_sec287
4684	BasicBlock* root = proc.addBlock();	4692	BasicBlock* root = proc.addBlock();
4685	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), value);	4693	Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), value);
4686	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argument);	4694	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argument);
4687	root->appendNew<ControlValue>(proc, Return, Origin(), asDouble);	4695	root->appendNewControlValue(proc, Return, Origin(), asDouble);
4688		4696
4689	CHECK(isIdentical(compileAndRun<double>(proc), static_cast<double>(value)));	4697	CHECK(isIdentical(compileAndRun<double>(proc), static_cast<double>(value)));
4690	}	4698	}
Lines 4696-4702 void testConvertFloatToDoubleMem(float v Source/JavaScriptCore/b3/testb3.cpp_sec288
4696	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4704	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4697	MemoryValue* loadedFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);	4705	MemoryValue* loadedFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);
4698	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), loadedFloat);	4706	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), loadedFloat);
4699	root->appendNew<ControlValue>(proc, Return, Origin(), asDouble);	4707	root->appendNewControlValue(proc, Return, Origin(), asDouble);
4700		4708
4701	CHECK(isIdentical(compileAndRun<double>(proc, &value), static_cast<double>(value)));	4709	CHECK(isIdentical(compileAndRun<double>(proc, &value), static_cast<double>(value)));
4702	}	4710	}
Lines 4709-4715 void testConvertDoubleToFloatToDoubleToF Source/JavaScriptCore/b3/testb3.cpp_sec289
4709	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), argument);	4717	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), argument);
4710	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), asFloat);	4718	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), asFloat);
4711	Value* asFloatAgain = root->appendNew<Value>(proc, DoubleToFloat, Origin(), asDouble);	4719	Value* asFloatAgain = root->appendNew<Value>(proc, DoubleToFloat, Origin(), asDouble);
4712	root->appendNew<ControlValue>(proc, Return, Origin(), asFloatAgain);	4720	root->appendNewControlValue(proc, Return, Origin(), asFloatAgain);
4713		4721
4714	CHECK(isIdentical(compileAndRun<float>(proc, value), static_cast<float>(value)));	4722	CHECK(isIdentical(compileAndRun<float>(proc, value), static_cast<float>(value)));
4715	}	4723	}
Lines 4725-4731 void testLoadFloatConvertDoubleConvertFl Source/JavaScriptCore/b3/testb3.cpp_sec290
4725	Value* asFloatAgain = root->appendNew<Value>(proc, DoubleToFloat, Origin(), asDouble);	4733	Value* asFloatAgain = root->appendNew<Value>(proc, DoubleToFloat, Origin(), asDouble);
4726	root->appendNew<MemoryValue>(proc, Store, Origin(), asFloatAgain, dst);	4734	root->appendNew<MemoryValue>(proc, Store, Origin(), asFloatAgain, dst);
4727		4735
4728	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	4736	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
4729		4737
4730	float input = value;	4738	float input = value;
4731	float output = 0.;	4739	float output = 0.;
Lines 4740-4746 void testFroundArg(double value) Source/JavaScriptCore/b3/testb3.cpp_sec291
4740	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	4748	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
4741	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), argument);	4749	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), argument);
4742	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), asFloat);	4750	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), asFloat);
4743	root->appendNew<ControlValue>(proc, Return, Origin(), asDouble);	4751	root->appendNewControlValue(proc, Return, Origin(), asDouble);
4744		4752
4745	CHECK(isIdentical(compileAndRun<double>(proc, value), static_cast<double>(static_cast<float>(value))));	4753	CHECK(isIdentical(compileAndRun<double>(proc, value), static_cast<double>(static_cast<float>(value))));
4746	}	4754	}
Lines 4753-4759 void testFroundMem(double value) Source/JavaScriptCore/b3/testb3.cpp_sec292
4753	MemoryValue* loadedDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);	4761	MemoryValue* loadedDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);
4754	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), loadedDouble);	4762	Value* asFloat = root->appendNew<Value>(proc, DoubleToFloat, Origin(), loadedDouble);
4755	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), asFloat);	4763	Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), asFloat);
4756	root->appendNew<ControlValue>(proc, Return, Origin(), asDouble);	4764	root->appendNewControlValue(proc, Return, Origin(), asDouble);
4757		4765
4758	CHECK(isIdentical(compileAndRun<double>(proc, &value), static_cast<double>(static_cast<float>(value))));	4766	CHECK(isIdentical(compileAndRun<double>(proc, &value), static_cast<double>(static_cast<float>(value))));
4759	}	4767	}
Lines 4764-4770 void testIToD64Arg() Source/JavaScriptCore/b3/testb3.cpp_sec293
4764	BasicBlock* root = proc.addBlock();	4772	BasicBlock* root = proc.addBlock();
4765	Value* src = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4773	Value* src = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4766	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), src);	4774	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), src);
4767	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsDouble);	4775	root->appendNewControlValue(proc, Return, Origin(), srcAsDouble);
4768		4776
4769	auto code = compile(proc);	4777	auto code = compile(proc);
4770	for (auto testValue : int64Operands())	4778	for (auto testValue : int64Operands())
Lines 4777-4783 void testIToF64Arg() Source/JavaScriptCore/b3/testb3.cpp_sec294
4777	BasicBlock* root = proc.addBlock();	4785	BasicBlock* root = proc.addBlock();
4778	Value* src = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4786	Value* src = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4779	Value* srcAsFloat = root->appendNew<Value>(proc, IToF, Origin(), src);	4787	Value* srcAsFloat = root->appendNew<Value>(proc, IToF, Origin(), src);
4780	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsFloat);	4788	root->appendNewControlValue(proc, Return, Origin(), srcAsFloat);
4781		4789
4782	auto code = compile(proc);	4790	auto code = compile(proc);
4783	for (auto testValue : int64Operands())	4791	for (auto testValue : int64Operands())
Lines 4791-4797 void testIToD32Arg() Source/JavaScriptCore/b3/testb3.cpp_sec295
4791	Value* src = root->appendNew<Value>(proc, Trunc, Origin(),	4799	Value* src = root->appendNew<Value>(proc, Trunc, Origin(),
4792	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	4800	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
4793	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), src);	4801	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), src);
4794	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsDouble);	4802	root->appendNewControlValue(proc, Return, Origin(), srcAsDouble);
4795		4803
4796	auto code = compile(proc);	4804	auto code = compile(proc);
4797	for (auto testValue : int32Operands())	4805	for (auto testValue : int32Operands())
Lines 4805-4811 void testIToF32Arg() Source/JavaScriptCore/b3/testb3.cpp_sec296
4805	Value* src = root->appendNew<Value>(proc, Trunc, Origin(),	4813	Value* src = root->appendNew<Value>(proc, Trunc, Origin(),
4806	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	4814	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
4807	Value* srcAsFloat = root->appendNew<Value>(proc, IToF, Origin(), src);	4815	Value* srcAsFloat = root->appendNew<Value>(proc, IToF, Origin(), src);
4808	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsFloat);	4816	root->appendNewControlValue(proc, Return, Origin(), srcAsFloat);
4809		4817
4810	auto code = compile(proc);	4818	auto code = compile(proc);
4811	for (auto testValue : int32Operands())	4819	for (auto testValue : int32Operands())
Lines 4819-4825 void testIToD64Mem() Source/JavaScriptCore/b3/testb3.cpp_sec297
4819	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4827	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4820	MemoryValue* loadedSrc = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);	4828	MemoryValue* loadedSrc = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);
4821	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), loadedSrc);	4829	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), loadedSrc);
4822	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsDouble);	4830	root->appendNewControlValue(proc, Return, Origin(), srcAsDouble);
4823		4831
4824	auto code = compile(proc);	4832	auto code = compile(proc);
4825	int64_t inMemoryValue;	4833	int64_t inMemoryValue;
Lines 4837-4843 void testIToF64Mem() Source/JavaScriptCore/b3/testb3.cpp_sec298
4837	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4845	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4838	MemoryValue* loadedSrc = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);	4846	MemoryValue* loadedSrc = root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), address);
4839	Value* srcAsFloat = root->appendNew<Value>(proc, IToF, Origin(), loadedSrc);	4847	Value* srcAsFloat = root->appendNew<Value>(proc, IToF, Origin(), loadedSrc);
4840	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsFloat);	4848	root->appendNewControlValue(proc, Return, Origin(), srcAsFloat);
4841		4849
4842	auto code = compile(proc);	4850	auto code = compile(proc);
4843	int64_t inMemoryValue;	4851	int64_t inMemoryValue;
Lines 4855-4861 void testIToD32Mem() Source/JavaScriptCore/b3/testb3.cpp_sec299
4855	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4863	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4856	MemoryValue* loadedSrc = root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), address);	4864	MemoryValue* loadedSrc = root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), address);
4857	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), loadedSrc);	4865	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), loadedSrc);
4858	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsDouble);	4866	root->appendNewControlValue(proc, Return, Origin(), srcAsDouble);
4859		4867
4860	auto code = compile(proc);	4868	auto code = compile(proc);
4861	int32_t inMemoryValue;	4869	int32_t inMemoryValue;
Lines 4873-4879 void testIToF32Mem() Source/JavaScriptCore/b3/testb3.cpp_sec300
4873	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4881	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4874	MemoryValue* loadedSrc = root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), address);	4882	MemoryValue* loadedSrc = root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), address);
4875	Value* srcAsFloat = root->appendNew<Value>(proc, IToF, Origin(), loadedSrc);	4883	Value* srcAsFloat = root->appendNew<Value>(proc, IToF, Origin(), loadedSrc);
4876	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsFloat);	4884	root->appendNewControlValue(proc, Return, Origin(), srcAsFloat);
4877		4885
4878	auto code = compile(proc);	4886	auto code = compile(proc);
4879	int32_t inMemoryValue;	4887	int32_t inMemoryValue;
Lines 4890-4896 void testIToD64Imm(int64_t value) Source/JavaScriptCore/b3/testb3.cpp_sec301
4890	BasicBlock* root = proc.addBlock();	4898	BasicBlock* root = proc.addBlock();
4891	Value* src = root->appendNew<Const64Value>(proc, Origin(), value);	4899	Value* src = root->appendNew<Const64Value>(proc, Origin(), value);
4892	Value* srcAsFloatingPoint = root->appendNew<Value>(proc, IToD, Origin(), src);	4900	Value* srcAsFloatingPoint = root->appendNew<Value>(proc, IToD, Origin(), src);
4893	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsFloatingPoint);	4901	root->appendNewControlValue(proc, Return, Origin(), srcAsFloatingPoint);
4894	CHECK(isIdentical(compileAndRun<double>(proc), static_cast<double>(value)));	4902	CHECK(isIdentical(compileAndRun<double>(proc), static_cast<double>(value)));
4895	}	4903	}
4896		4904
Lines 4900-4906 void testIToF64Imm(int64_t value) Source/JavaScriptCore/b3/testb3.cpp_sec302
4900	BasicBlock* root = proc.addBlock();	4908	BasicBlock* root = proc.addBlock();
4901	Value* src = root->appendNew<Const64Value>(proc, Origin(), value);	4909	Value* src = root->appendNew<Const64Value>(proc, Origin(), value);
4902	Value* srcAsFloatingPoint = root->appendNew<Value>(proc, IToF, Origin(), src);	4910	Value* srcAsFloatingPoint = root->appendNew<Value>(proc, IToF, Origin(), src);
4903	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsFloatingPoint);	4911	root->appendNewControlValue(proc, Return, Origin(), srcAsFloatingPoint);
4904	CHECK(isIdentical(compileAndRun<float>(proc), static_cast<float>(value)));	4912	CHECK(isIdentical(compileAndRun<float>(proc), static_cast<float>(value)));
4905	}	4913	}
4906		4914
Lines 4910-4916 void testIToD32Imm(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec303
4910	BasicBlock* root = proc.addBlock();	4918	BasicBlock* root = proc.addBlock();
4911	Value* src = root->appendNew<Const32Value>(proc, Origin(), value);	4919	Value* src = root->appendNew<Const32Value>(proc, Origin(), value);
4912	Value* srcAsFloatingPoint = root->appendNew<Value>(proc, IToD, Origin(), src);	4920	Value* srcAsFloatingPoint = root->appendNew<Value>(proc, IToD, Origin(), src);
4913	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsFloatingPoint);	4921	root->appendNewControlValue(proc, Return, Origin(), srcAsFloatingPoint);
4914	CHECK(isIdentical(compileAndRun<double>(proc), static_cast<double>(value)));	4922	CHECK(isIdentical(compileAndRun<double>(proc), static_cast<double>(value)));
4915	}	4923	}
4916		4924
Lines 4920-4926 void testIToF32Imm(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec304
4920	BasicBlock* root = proc.addBlock();	4928	BasicBlock* root = proc.addBlock();
4921	Value* src = root->appendNew<Const32Value>(proc, Origin(), value);	4929	Value* src = root->appendNew<Const32Value>(proc, Origin(), value);
4922	Value* srcAsFloatingPoint = root->appendNew<Value>(proc, IToF, Origin(), src);	4930	Value* srcAsFloatingPoint = root->appendNew<Value>(proc, IToF, Origin(), src);
4923	root->appendNew<ControlValue>(proc, Return, Origin(), srcAsFloatingPoint);	4931	root->appendNewControlValue(proc, Return, Origin(), srcAsFloatingPoint);
4924	CHECK(isIdentical(compileAndRun<float>(proc), static_cast<float>(value)));	4932	CHECK(isIdentical(compileAndRun<float>(proc), static_cast<float>(value)));
4925	}	4933	}
4926		4934
Lines 4931-4937 void testIToDReducedToIToF64Arg() Source/JavaScriptCore/b3/testb3.cpp_sec305
4931	Value* src = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	4939	Value* src = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
4932	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), src);	4940	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), src);
4933	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), srcAsDouble);	4941	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), srcAsDouble);
4934	root->appendNew<ControlValue>(proc, Return, Origin(), floatResult);	4942	root->appendNewControlValue(proc, Return, Origin(), floatResult);
4935		4943
4936	auto code = compile(proc);	4944	auto code = compile(proc);
4937	for (auto testValue : int64Operands())	4945	for (auto testValue : int64Operands())
Lines 4946-4952 void testIToDReducedToIToF32Arg() Source/JavaScriptCore/b3/testb3.cpp_sec306
4946	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	4954	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
4947	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), src);	4955	Value* srcAsDouble = root->appendNew<Value>(proc, IToD, Origin(), src);
4948	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), srcAsDouble);	4956	Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), srcAsDouble);
4949	root->appendNew<ControlValue>(proc, Return, Origin(), floatResult);	4957	root->appendNewControlValue(proc, Return, Origin(), floatResult);
4950		4958
4951	auto code = compile(proc);	4959	auto code = compile(proc);
4952	for (auto testValue : int32Operands())	4960	for (auto testValue : int32Operands())
Lines 4964-4970 void testStore32(int value) Source/JavaScriptCore/b3/testb3.cpp_sec307
4964	proc, Trunc, Origin(),	4972	proc, Trunc, Origin(),
4965	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	4973	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
4966	root->appendNew<ConstPtrValue>(proc, Origin(), &slot));	4974	root->appendNew<ConstPtrValue>(proc, Origin(), &slot));
4967	root->appendNew<ControlValue>(	4975	root->appendNewControlValue(
4968	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	4976	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
4969		4977
4970	CHECK(!compileAndRun<int>(proc, value));	4978	CHECK(!compileAndRun<int>(proc, value));
Lines 4980-4986 void testStoreConstant(int value) Source/JavaScriptCore/b3/testb3.cpp_sec308
4980	proc, Store, Origin(),	4988	proc, Store, Origin(),
4981	root->appendNew<Const32Value>(proc, Origin(), value),	4989	root->appendNew<Const32Value>(proc, Origin(), value),
4982	root->appendNew<ConstPtrValue>(proc, Origin(), &slot));	4990	root->appendNew<ConstPtrValue>(proc, Origin(), &slot));
4983	root->appendNew<ControlValue>(	4991	root->appendNewControlValue(
4984	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	4992	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
4985		4993
4986	CHECK(!compileAndRun<int>(proc));	4994	CHECK(!compileAndRun<int>(proc));
Lines 5000-5006 void testStoreConstantPtr(intptr_t value Source/JavaScriptCore/b3/testb3.cpp_sec309
5000	proc, Store, Origin(),	5008	proc, Store, Origin(),
5001	root->appendNew<ConstPtrValue>(proc, Origin(), value),	5009	root->appendNew<ConstPtrValue>(proc, Origin(), value),
5002	root->appendNew<ConstPtrValue>(proc, Origin(), &slot));	5010	root->appendNew<ConstPtrValue>(proc, Origin(), &slot));
5003	root->appendNew<ControlValue>(	5011	root->appendNewControlValue(
5004	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	5012	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
5005		5013
5006	CHECK(!compileAndRun<int>(proc));	5014	CHECK(!compileAndRun<int>(proc));
Lines 5018-5024 void testStore8Arg() Source/JavaScriptCore/b3/testb3.cpp_sec310
5018	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	5026	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
5019		5027
5020	root->appendNew<MemoryValue>(proc, Store8, Origin(), value, address);	5028	root->appendNew<MemoryValue>(proc, Store8, Origin(), value, address);
5021	root->appendNew<ControlValue>(proc, Return, Origin(), value);	5029	root->appendNewControlValue(proc, Return, Origin(), value);
5022		5030
5023	int8_t storage = 0;	5031	int8_t storage = 0;
5024	CHECK(compileAndRun<int64_t>(proc, 42, &storage) == 42);	5032	CHECK(compileAndRun<int64_t>(proc, 42, &storage) == 42);
Lines 5039-5045 void testStore8Arg() Source/JavaScriptCore/b3/testb3.cpp_sec311
5039	Value* address = root->appendNew<Value>(proc, Add, Origin(), baseDisplacement, offset);	5047	Value* address = root->appendNew<Value>(proc, Add, Origin(), baseDisplacement, offset);
5040		5048
5041	root->appendNew<MemoryValue>(proc, Store8, Origin(), value, address);	5049	root->appendNew<MemoryValue>(proc, Store8, Origin(), value, address);
5042	root->appendNew<ControlValue>(proc, Return, Origin(), value);	5050	root->appendNewControlValue(proc, Return, Origin(), value);
5043		5051
5044	int8_t storage = 0;	5052	int8_t storage = 0;
5045	CHECK(compileAndRun<int64_t>(proc, 42, &storage, 1) == 42);	5053	CHECK(compileAndRun<int64_t>(proc, 42, &storage, 1) == 42);
Lines 5057-5063 void testStore8Imm() Source/JavaScriptCore/b3/testb3.cpp_sec312
5057	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	5065	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
5058		5066
5059	root->appendNew<MemoryValue>(proc, Store8, Origin(), value, address);	5067	root->appendNew<MemoryValue>(proc, Store8, Origin(), value, address);
5060	root->appendNew<ControlValue>(proc, Return, Origin(), value);	5068	root->appendNewControlValue(proc, Return, Origin(), value);
5061		5069
5062	int8_t storage = 0;	5070	int8_t storage = 0;
5063	CHECK(compileAndRun<int64_t>(proc, &storage) == 42);	5071	CHECK(compileAndRun<int64_t>(proc, &storage) == 42);
Lines 5077-5083 void testStore8Imm() Source/JavaScriptCore/b3/testb3.cpp_sec313
5077	Value* address = root->appendNew<Value>(proc, Add, Origin(), baseDisplacement, offset);	5085	Value* address = root->appendNew<Value>(proc, Add, Origin(), baseDisplacement, offset);
5078		5086
5079	root->appendNew<MemoryValue>(proc, Store8, Origin(), value, address);	5087	root->appendNew<MemoryValue>(proc, Store8, Origin(), value, address);
5080	root->appendNew<ControlValue>(proc, Return, Origin(), value);	5088	root->appendNewControlValue(proc, Return, Origin(), value);
5081		5089
5082	int8_t storage = 0;	5090	int8_t storage = 0;
5083	CHECK(compileAndRun<int64_t>(proc, &storage, 1) == 42);	5091	CHECK(compileAndRun<int64_t>(proc, &storage, 1) == 42);
Lines 5129-5135 void testStorePartial8BitRegisterOnX86() Source/JavaScriptCore/b3/testb3.cpp_sec314
5129	// if we use X86 partial registers.	5137	// if we use X86 partial registers.
5130	root->appendNew<MemoryValue>(proc, Store8, Origin(), patchpoint, whereToStore);	5138	root->appendNew<MemoryValue>(proc, Store8, Origin(), patchpoint, whereToStore);
5131		5139
5132	root->appendNew<ControlValue>(proc, Return, Origin(), returnValue);	5140	root->appendNewControlValue(proc, Return, Origin(), returnValue);
5133		5141
5134	int8_t storage = 0xff;	5142	int8_t storage = 0xff;
5135	CHECK(compileAndRun<int64_t>(proc, 0x12345678abcdef12, &storage) == 0x12345678abcdef12);	5143	CHECK(compileAndRun<int64_t>(proc, 0x12345678abcdef12, &storage) == 0x12345678abcdef12);
Lines 5147-5153 void testStore16Arg() Source/JavaScriptCore/b3/testb3.cpp_sec315
5147	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	5155	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
5148		5156
5149	root->appendNew<MemoryValue>(proc, Store16, Origin(), value, address);	5157	root->appendNew<MemoryValue>(proc, Store16, Origin(), value, address);
5150	root->appendNew<ControlValue>(proc, Return, Origin(), value);	5158	root->appendNewControlValue(proc, Return, Origin(), value);
5151		5159
5152	int16_t storage = -1;	5160	int16_t storage = -1;
5153	CHECK(compileAndRun<int64_t>(proc, 42, &storage) == 42);	5161	CHECK(compileAndRun<int64_t>(proc, 42, &storage) == 42);
Lines 5168-5174 void testStore16Arg() Source/JavaScriptCore/b3/testb3.cpp_sec316
5168	Value* address = root->appendNew<Value>(proc, Add, Origin(), baseDisplacement, offset);	5176	Value* address = root->appendNew<Value>(proc, Add, Origin(), baseDisplacement, offset);
5169		5177
5170	root->appendNew<MemoryValue>(proc, Store16, Origin(), value, address);	5178	root->appendNew<MemoryValue>(proc, Store16, Origin(), value, address);
5171	root->appendNew<ControlValue>(proc, Return, Origin(), value);	5179	root->appendNewControlValue(proc, Return, Origin(), value);
5172		5180
5173	int16_t storage = -1;	5181	int16_t storage = -1;
5174	CHECK(compileAndRun<int64_t>(proc, 42, &storage, 1) == 42);	5182	CHECK(compileAndRun<int64_t>(proc, 42, &storage, 1) == 42);
Lines 5186-5192 void testStore16Imm() Source/JavaScriptCore/b3/testb3.cpp_sec317
5186	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	5194	Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
5187		5195
5188	root->appendNew<MemoryValue>(proc, Store16, Origin(), value, address);	5196	root->appendNew<MemoryValue>(proc, Store16, Origin(), value, address);
5189	root->appendNew<ControlValue>(proc, Return, Origin(), value);	5197	root->appendNewControlValue(proc, Return, Origin(), value);
5190		5198
5191	int16_t storage = -1;	5199	int16_t storage = -1;
5192	CHECK(compileAndRun<int64_t>(proc, &storage) == 42);	5200	CHECK(compileAndRun<int64_t>(proc, &storage) == 42);
Lines 5206-5212 void testStore16Imm() Source/JavaScriptCore/b3/testb3.cpp_sec318
5206	Value* address = root->appendNew<Value>(proc, Add, Origin(), baseDisplacement, offset);	5214	Value* address = root->appendNew<Value>(proc, Add, Origin(), baseDisplacement, offset);
5207		5215
5208	root->appendNew<MemoryValue>(proc, Store16, Origin(), value, address);	5216	root->appendNew<MemoryValue>(proc, Store16, Origin(), value, address);
5209	root->appendNew<ControlValue>(proc, Return, Origin(), value);	5217	root->appendNewControlValue(proc, Return, Origin(), value);
5210		5218
5211	int16_t storage = -1;	5219	int16_t storage = -1;
5212	CHECK(compileAndRun<int64_t>(proc, &storage, 1) == 42);	5220	CHECK(compileAndRun<int64_t>(proc, &storage, 1) == 42);
Lines 5218-5224 void testTrunc(int64_t value) Source/JavaScriptCore/b3/testb3.cpp_sec319
5218	{	5226	{
5219	Procedure proc;	5227	Procedure proc;
5220	BasicBlock* root = proc.addBlock();	5228	BasicBlock* root = proc.addBlock();
5221	root->appendNew<ControlValue>(	5229	root->appendNewControlValue(
5222	proc, Return, Origin(),	5230	proc, Return, Origin(),
5223	root->appendNew<Value>(	5231	root->appendNew<Value>(
5224	proc, Trunc, Origin(),	5232	proc, Trunc, Origin(),
Lines 5231-5237 void testAdd1(int value) Source/JavaScriptCore/b3/testb3.cpp_sec320
5231	{	5239	{
5232	Procedure proc;	5240	Procedure proc;
5233	BasicBlock* root = proc.addBlock();	5241	BasicBlock* root = proc.addBlock();
5234	root->appendNew<ControlValue>(	5242	root->appendNewControlValue(
5235	proc, Return, Origin(),	5243	proc, Return, Origin(),
5236	root->appendNew<Value>(	5244	root->appendNew<Value>(
5237	proc, Add, Origin(),	5245	proc, Add, Origin(),
Lines 5247-5253 void testAdd1Ptr(intptr_t value) Source/JavaScriptCore/b3/testb3.cpp_sec321
5247	{	5255	{
5248	Procedure proc;	5256	Procedure proc;
5249	BasicBlock* root = proc.addBlock();	5257	BasicBlock* root = proc.addBlock();
5250	root->appendNew<ControlValue>(	5258	root->appendNewControlValue(
5251	proc, Return, Origin(),	5259	proc, Return, Origin(),
5252	root->appendNew<Value>(	5260	root->appendNew<Value>(
5253	proc, Add, Origin(),	5261	proc, Add, Origin(),
Lines 5261-5267 void testNeg32(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec322
5261	{	5269	{
5262	Procedure proc;	5270	Procedure proc;
5263	BasicBlock* root = proc.addBlock();	5271	BasicBlock* root = proc.addBlock();
5264	root->appendNew<ControlValue>(	5272	root->appendNewControlValue(
5265	proc, Return, Origin(),	5273	proc, Return, Origin(),
5266	root->appendNew<Value>(	5274	root->appendNew<Value>(
5267	proc, Sub, Origin(),	5275	proc, Sub, Origin(),
Lines 5277-5283 void testNegPtr(intptr_t value) Source/JavaScriptCore/b3/testb3.cpp_sec323
5277	{	5285	{
5278	Procedure proc;	5286	Procedure proc;
5279	BasicBlock* root = proc.addBlock();	5287	BasicBlock* root = proc.addBlock();
5280	root->appendNew<ControlValue>(	5288	root->appendNewControlValue(
5281	proc, Return, Origin(),	5289	proc, Return, Origin(),
5282	root->appendNew<Value>(	5290	root->appendNew<Value>(
5283	proc, Sub, Origin(),	5291	proc, Sub, Origin(),
Lines 5302-5308 void testStoreAddLoad32(int amount) Source/JavaScriptCore/b3/testb3.cpp_sec324
5302	proc, Trunc, Origin(),	5310	proc, Trunc, Origin(),
5303	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),	5311	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
5304	slotPtr);	5312	slotPtr);
5305	root->appendNew<ControlValue>(	5313	root->appendNewControlValue(
5306	proc, Return, Origin(),	5314	proc, Return, Origin(),
5307	root->appendNew<Const32Value>(proc, Origin(), 0));	5315	root->appendNew<Const32Value>(proc, Origin(), 0));
5308		5316
Lines 5323-5329 void testStoreAddLoadImm32(int amount) Source/JavaScriptCore/b3/testb3.cpp_sec325
5323	root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), slotPtr),	5331	root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), slotPtr),
5324	root->appendNew<Const32Value>(proc, Origin(), amount)),	5332	root->appendNew<Const32Value>(proc, Origin(), amount)),
5325	slotPtr);	5333	slotPtr);
5326	root->appendNew<ControlValue>(	5334	root->appendNewControlValue(
5327	proc, Return, Origin(),	5335	proc, Return, Origin(),
5328	root->appendNew<Const32Value>(proc, Origin(), 0));	5336	root->appendNew<Const32Value>(proc, Origin(), 0));
5329		5337
Lines 5346-5352 void testStoreAddLoad8(int amount, B3::O Source/JavaScriptCore/b3/testb3.cpp_sec326
5346	proc, Trunc, Origin(),	5354	proc, Trunc, Origin(),
5347	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),	5355	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
5348	slotPtr);	5356	slotPtr);
5349	root->appendNew<ControlValue>(	5357	root->appendNewControlValue(
5350	proc, Return, Origin(),	5358	proc, Return, Origin(),
5351	root->appendNew<Const32Value>(proc, Origin(), 0));	5359	root->appendNew<Const32Value>(proc, Origin(), 0));
5352		5360
Lines 5367-5373 void testStoreAddLoadImm8(int amount, B3 Source/JavaScriptCore/b3/testb3.cpp_sec327
5367	root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),	5375	root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),
5368	root->appendNew<Const32Value>(proc, Origin(), amount)),	5376	root->appendNew<Const32Value>(proc, Origin(), amount)),
5369	slotPtr);	5377	slotPtr);
5370	root->appendNew<ControlValue>(	5378	root->appendNewControlValue(
5371	proc, Return, Origin(),	5379	proc, Return, Origin(),
5372	root->appendNew<Const32Value>(proc, Origin(), 0));	5380	root->appendNew<Const32Value>(proc, Origin(), 0));
5373		5381
Lines 5390-5396 void testStoreAddLoad16(int amount, B3:: Source/JavaScriptCore/b3/testb3.cpp_sec328
5390	proc, Trunc, Origin(),	5398	proc, Trunc, Origin(),
5391	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),	5399	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
5392	slotPtr);	5400	slotPtr);
5393	root->appendNew<ControlValue>(	5401	root->appendNewControlValue(
5394	proc, Return, Origin(),	5402	proc, Return, Origin(),
5395	root->appendNew<Const32Value>(proc, Origin(), 0));	5403	root->appendNew<Const32Value>(proc, Origin(), 0));
5396		5404
Lines 5411-5417 void testStoreAddLoadImm16(int amount, B Source/JavaScriptCore/b3/testb3.cpp_sec329
5411	root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),	5419	root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),
5412	root->appendNew<Const32Value>(proc, Origin(), amount)),	5420	root->appendNew<Const32Value>(proc, Origin(), amount)),
5413	slotPtr);	5421	slotPtr);
5414	root->appendNew<ControlValue>(	5422	root->appendNewControlValue(
5415	proc, Return, Origin(),	5423	proc, Return, Origin(),
5416	root->appendNew<Const32Value>(proc, Origin(), 0));	5424	root->appendNew<Const32Value>(proc, Origin(), 0));
5417		5425
Lines 5432-5438 void testStoreAddLoad64(int amount) Source/JavaScriptCore/b3/testb3.cpp_sec330
5432	root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),	5440	root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),
5433	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	5441	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
5434	slotPtr);	5442	slotPtr);
5435	root->appendNew<ControlValue>(	5443	root->appendNewControlValue(
5436	proc, Return, Origin(),	5444	proc, Return, Origin(),
5437	root->appendNew<Const32Value>(proc, Origin(), 0));	5445	root->appendNew<Const32Value>(proc, Origin(), 0));
5438		5446
Lines 5453-5459 void testStoreAddLoadImm64(int64_t amoun Source/JavaScriptCore/b3/testb3.cpp_sec331
5453	root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),	5461	root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),
5454	root->appendNew<Const64Value>(proc, Origin(), amount)),	5462	root->appendNew<Const64Value>(proc, Origin(), amount)),
5455	slotPtr);	5463	slotPtr);
5456	root->appendNew<ControlValue>(	5464	root->appendNewControlValue(
5457	proc, Return, Origin(),	5465	proc, Return, Origin(),
5458	root->appendNew<Const32Value>(proc, Origin(), 0));	5466	root->appendNew<Const32Value>(proc, Origin(), 0));
5459		5467
Lines 5485-5491 void testStoreAddLoad32Index(int amount) Source/JavaScriptCore/b3/testb3.cpp_sec332
5485	proc, Trunc, Origin(),	5493	proc, Trunc, Origin(),
5486	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),	5494	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
5487	slotPtr);	5495	slotPtr);
5488	root->appendNew<ControlValue>(	5496	root->appendNewControlValue(
5489	proc, Return, Origin(),	5497	proc, Return, Origin(),
5490	root->appendNew<Const32Value>(proc, Origin(), 0));	5498	root->appendNew<Const32Value>(proc, Origin(), 0));
5491		5499
Lines 5515-5521 void testStoreAddLoadImm32Index(int amou Source/JavaScriptCore/b3/testb3.cpp_sec333
5515	root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), slotPtr),	5523	root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), slotPtr),
5516	root->appendNew<Const32Value>(proc, Origin(), amount)),	5524	root->appendNew<Const32Value>(proc, Origin(), amount)),
5517	slotPtr);	5525	slotPtr);
5518	root->appendNew<ControlValue>(	5526	root->appendNewControlValue(
5519	proc, Return, Origin(),	5527	proc, Return, Origin(),
5520	root->appendNew<Const32Value>(proc, Origin(), 0));	5528	root->appendNew<Const32Value>(proc, Origin(), 0));
5521		5529
Lines 5547-5553 void testStoreAddLoad8Index(int amount, Source/JavaScriptCore/b3/testb3.cpp_sec334
5547	proc, Trunc, Origin(),	5555	proc, Trunc, Origin(),
5548	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),	5556	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
5549	slotPtr);	5557	slotPtr);
5550	root->appendNew<ControlValue>(	5558	root->appendNewControlValue(
5551	proc, Return, Origin(),	5559	proc, Return, Origin(),
5552	root->appendNew<Const32Value>(proc, Origin(), 0));	5560	root->appendNew<Const32Value>(proc, Origin(), 0));
5553		5561
Lines 5577-5583 void testStoreAddLoadImm8Index(int amoun Source/JavaScriptCore/b3/testb3.cpp_sec335
5577	root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),	5585	root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),
5578	root->appendNew<Const32Value>(proc, Origin(), amount)),	5586	root->appendNew<Const32Value>(proc, Origin(), amount)),
5579	slotPtr);	5587	slotPtr);
5580	root->appendNew<ControlValue>(	5588	root->appendNewControlValue(
5581	proc, Return, Origin(),	5589	proc, Return, Origin(),
5582	root->appendNew<Const32Value>(proc, Origin(), 0));	5590	root->appendNew<Const32Value>(proc, Origin(), 0));
5583		5591
Lines 5609-5615 void testStoreAddLoad16Index(int amount, Source/JavaScriptCore/b3/testb3.cpp_sec336
5609	proc, Trunc, Origin(),	5617	proc, Trunc, Origin(),
5610	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),	5618	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
5611	slotPtr);	5619	slotPtr);
5612	root->appendNew<ControlValue>(	5620	root->appendNewControlValue(
5613	proc, Return, Origin(),	5621	proc, Return, Origin(),
5614	root->appendNew<Const32Value>(proc, Origin(), 0));	5622	root->appendNew<Const32Value>(proc, Origin(), 0));
5615		5623
Lines 5639-5645 void testStoreAddLoadImm16Index(int amou Source/JavaScriptCore/b3/testb3.cpp_sec337
5639	root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),	5647	root->appendNew<MemoryValue>(proc, loadOpcode, Origin(), slotPtr),
5640	root->appendNew<Const32Value>(proc, Origin(), amount)),	5648	root->appendNew<Const32Value>(proc, Origin(), amount)),
5641	slotPtr);	5649	slotPtr);
5642	root->appendNew<ControlValue>(	5650	root->appendNewControlValue(
5643	proc, Return, Origin(),	5651	proc, Return, Origin(),
5644	root->appendNew<Const32Value>(proc, Origin(), 0));	5652	root->appendNew<Const32Value>(proc, Origin(), 0));
5645		5653
Lines 5669-5675 void testStoreAddLoad64Index(int amount) Source/JavaScriptCore/b3/testb3.cpp_sec338
5669	root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),	5677	root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),
5670	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	5678	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
5671	slotPtr);	5679	slotPtr);
5672	root->appendNew<ControlValue>(	5680	root->appendNewControlValue(
5673	proc, Return, Origin(),	5681	proc, Return, Origin(),
5674	root->appendNew<Const32Value>(proc, Origin(), 0));	5682	root->appendNew<Const32Value>(proc, Origin(), 0));
5675		5683
Lines 5699-5705 void testStoreAddLoadImm64Index(int64_t Source/JavaScriptCore/b3/testb3.cpp_sec339
5699	root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),	5707	root->appendNew<MemoryValue>(proc, Load, Int64, Origin(), slotPtr),
5700	root->appendNew<Const64Value>(proc, Origin(), amount)),	5708	root->appendNew<Const64Value>(proc, Origin(), amount)),
5701	slotPtr);	5709	slotPtr);
5702	root->appendNew<ControlValue>(	5710	root->appendNewControlValue(
5703	proc, Return, Origin(),	5711	proc, Return, Origin(),
5704	root->appendNew<Const32Value>(proc, Origin(), 0));	5712	root->appendNew<Const32Value>(proc, Origin(), 0));
5705		5713
Lines 5723-5729 void testStoreSubLoad(int amount) Source/JavaScriptCore/b3/testb3.cpp_sec340
5723	proc, Trunc, Origin(),	5731	proc, Trunc, Origin(),
5724	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),	5732	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
5725	slotPtr);	5733	slotPtr);
5726	root->appendNew<ControlValue>(	5734	root->appendNewControlValue(
5727	proc, Return, Origin(),	5735	proc, Return, Origin(),
5728	root->appendNew<Const32Value>(proc, Origin(), 0));	5736	root->appendNew<Const32Value>(proc, Origin(), 0));
5729		5737
Lines 5750-5756 void testStoreAddLoadInterference(int am Source/JavaScriptCore/b3/testb3.cpp_sec341
5750	proc, Add, Origin(),	5758	proc, Add, Origin(),
5751	load, root->appendNew<Const32Value>(proc, Origin(), amount)),	5759	load, root->appendNew<Const32Value>(proc, Origin(), amount)),
5752	slotPtr);	5760	slotPtr);
5753	root->appendNew<ControlValue>(	5761	root->appendNewControlValue(
5754	proc, Return, Origin(),	5762	proc, Return, Origin(),
5755	root->appendNew<Const32Value>(proc, Origin(), 0));	5763	root->appendNew<Const32Value>(proc, Origin(), 0));
5756		5764
Lines 5774-5780 void testStoreAddAndLoad(int amount, int Source/JavaScriptCore/b3/testb3.cpp_sec342
5774	root->appendNew<Const32Value>(proc, Origin(), amount)),	5782	root->appendNew<Const32Value>(proc, Origin(), amount)),
5775	root->appendNew<Const32Value>(proc, Origin(), mask)),	5783	root->appendNew<Const32Value>(proc, Origin(), mask)),
5776	slotPtr);	5784	slotPtr);
5777	root->appendNew<ControlValue>(	5785	root->appendNewControlValue(
5778	proc, Return, Origin(),	5786	proc, Return, Origin(),
5779	root->appendNew<Const32Value>(proc, Origin(), 0));	5787	root->appendNew<Const32Value>(proc, Origin(), 0));
5780		5788
Lines 5799-5805 void testStoreNegLoad32(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec343
5799	root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), slotPtr)),	5807	root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), slotPtr)),
5800	slotPtr);	5808	slotPtr);
5801		5809
5802	root->appendNew<ControlValue>(	5810	root->appendNewControlValue(
5803	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	5811	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
5804		5812
5805	CHECK(!compileAndRun<int32_t>(proc));	5813	CHECK(!compileAndRun<int32_t>(proc));
Lines 5823-5829 void testStoreNegLoadPtr(intptr_t value) Source/JavaScriptCore/b3/testb3.cpp_sec344
5823	root->appendNew<MemoryValue>(proc, Load, pointerType(), Origin(), slotPtr)),	5831	root->appendNew<MemoryValue>(proc, Load, pointerType(), Origin(), slotPtr)),
5824	slotPtr);	5832	slotPtr);
5825		5833
5826	root->appendNew<ControlValue>(	5834	root->appendNewControlValue(
5827	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	5835	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
5828		5836
5829	CHECK(!compileAndRun<int32_t>(proc));	5837	CHECK(!compileAndRun<int32_t>(proc));
Lines 5834-5840 void testAdd1Uncommuted(int value) Source/JavaScriptCore/b3/testb3.cpp_sec345
5834	{	5842	{
5835	Procedure proc;	5843	Procedure proc;
5836	BasicBlock* root = proc.addBlock();	5844	BasicBlock* root = proc.addBlock();
5837	root->appendNew<ControlValue>(	5845	root->appendNewControlValue(
5838	proc, Return, Origin(),	5846	proc, Return, Origin(),
5839	root->appendNew<Value>(	5847	root->appendNew<Value>(
5840	proc, Add, Origin(),	5848	proc, Add, Origin(),
Lines 5852-5858 void testLoadOffset() Source/JavaScriptCore/b3/testb3.cpp_sec346
5852	BasicBlock* root = proc.addBlock();	5860	BasicBlock* root = proc.addBlock();
5853	int array[] = { 1, 2 };	5861	int array[] = { 1, 2 };
5854	ConstPtrValue* arrayPtr = root->appendNew<ConstPtrValue>(proc, Origin(), array);	5862	ConstPtrValue* arrayPtr = root->appendNew<ConstPtrValue>(proc, Origin(), array);
5855	root->appendNew<ControlValue>(	5863	root->appendNewControlValue(
5856	proc, Return, Origin(),	5864	proc, Return, Origin(),
5857	root->appendNew<Value>(	5865	root->appendNew<Value>(
5858	proc, Add, Origin(),	5866	proc, Add, Origin(),
Lines 5868-5874 void testLoadOffsetNotConstant() Source/JavaScriptCore/b3/testb3.cpp_sec347
5868	BasicBlock* root = proc.addBlock();	5876	BasicBlock* root = proc.addBlock();
5869	int array[] = { 1, 2 };	5877	int array[] = { 1, 2 };
5870	Value* arrayPtr = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	5878	Value* arrayPtr = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
5871	root->appendNew<ControlValue>(	5879	root->appendNewControlValue(
5872	proc, Return, Origin(),	5880	proc, Return, Origin(),
5873	root->appendNew<Value>(	5881	root->appendNew<Value>(
5874	proc, Add, Origin(),	5882	proc, Add, Origin(),
Lines 5884-5890 void testLoadOffsetUsingAdd() Source/JavaScriptCore/b3/testb3.cpp_sec348
5884	BasicBlock* root = proc.addBlock();	5892	BasicBlock* root = proc.addBlock();
5885	int array[] = { 1, 2 };	5893	int array[] = { 1, 2 };
5886	ConstPtrValue* arrayPtr = root->appendNew<ConstPtrValue>(proc, Origin(), array);	5894	ConstPtrValue* arrayPtr = root->appendNew<ConstPtrValue>(proc, Origin(), array);
5887	root->appendNew<ControlValue>(	5895	root->appendNewControlValue(
5888	proc, Return, Origin(),	5896	proc, Return, Origin(),
5889	root->appendNew<Value>(	5897	root->appendNew<Value>(
5890	proc, Add, Origin(),	5898	proc, Add, Origin(),
Lines 5925-5931 void testLoadOffsetUsingAddInterference( Source/JavaScriptCore/b3/testb3.cpp_sec349
5925	proc, Store, Origin(), theNumberOfTheBeast, otherArrayPtr, 0);	5933	proc, Store, Origin(), theNumberOfTheBeast, otherArrayPtr, 0);
5926	root->appendNew<MemoryValue>(	5934	root->appendNew<MemoryValue>(
5927	proc, Store, Origin(), theNumberOfTheBeast, otherArrayPtr, sizeof(int));	5935	proc, Store, Origin(), theNumberOfTheBeast, otherArrayPtr, sizeof(int));
5928	root->appendNew<ControlValue>(	5936	root->appendNewControlValue(
5929	proc, Return, Origin(),	5937	proc, Return, Origin(),
5930	root->appendNew<Value>(	5938	root->appendNew<Value>(
5931	proc, Add, Origin(), left, right));	5939	proc, Add, Origin(), left, right));
Lines 5941-5947 void testLoadOffsetUsingAddNotConstant() Source/JavaScriptCore/b3/testb3.cpp_sec350
5941	BasicBlock* root = proc.addBlock();	5949	BasicBlock* root = proc.addBlock();
5942	int array[] = { 1, 2 };	5950	int array[] = { 1, 2 };
5943	Value* arrayPtr = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	5951	Value* arrayPtr = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
5944	root->appendNew<ControlValue>(	5952	root->appendNewControlValue(
5945	proc, Return, Origin(),	5953	proc, Return, Origin(),
5946	root->appendNew<Value>(	5954	root->appendNew<Value>(
5947	proc, Add, Origin(),	5955	proc, Add, Origin(),
Lines 5977-5983 void testLoadAddrShift(unsigned shift) Source/JavaScriptCore/b3/testb3.cpp_sec351
5977		5985
5978	*slot = 8675309;	5986	*slot = 8675309;
5979		5987
5980	root->appendNew<ControlValue>(	5988	root->appendNewControlValue(
5981	proc, Return, Origin(),	5989	proc, Return, Origin(),
5982	root->appendNew<MemoryValue>(	5990	root->appendNew<MemoryValue>(
5983	proc, Load, Int32, Origin(),	5991	proc, Load, Int32, Origin(),
Lines 5993-5999 void testFramePointer() Source/JavaScriptCore/b3/testb3.cpp_sec352
5993	{	6001	{
5994	Procedure proc;	6002	Procedure proc;
5995	BasicBlock* root = proc.addBlock();	6003	BasicBlock* root = proc.addBlock();
5996	root->appendNew<ControlValue>(	6004	root->appendNewControlValue(
5997	proc, Return, Origin(),	6005	proc, Return, Origin(),
5998	root->appendNew<Value>(proc, FramePointer, Origin()));	6006	root->appendNew<Value>(proc, FramePointer, Origin()));
5999		6007
Lines 6016-6022 void testOverrideFramePointer() Source/JavaScriptCore/b3/testb3.cpp_sec353
6016	Value* fp = root->appendNew<Value>(proc, FramePointer, Origin());	6024	Value* fp = root->appendNew<Value>(proc, FramePointer, Origin());
6017	Value* result = root->appendNew<Value>(proc, Sub, Origin(), fp, offset);	6025	Value* result = root->appendNew<Value>(proc, Sub, Origin(), fp, offset);
6018		6026
6019	root->appendNew<ControlValue>(proc, Return, Origin(), result);	6027	root->appendNewControlValue(proc, Return, Origin(), result);
6020	CHECK(compileAndRun<int64_t>(proc, 1));	6028	CHECK(compileAndRun<int64_t>(proc, 1));
6021	}	6029	}
6022	{	6030	{
Lines 6032-6038 void testOverrideFramePointer() Source/JavaScriptCore/b3/testb3.cpp_sec354
6032	Value* offsetArg = root->appendNew<Value>(proc, Add, Origin(), offset, arg);	6040	Value* offsetArg = root->appendNew<Value>(proc, Add, Origin(), offset, arg);
6033	Value* result = root->appendNew<Value>(proc, Add, Origin(), offsetArg, offsetFP);	6041	Value* result = root->appendNew<Value>(proc, Add, Origin(), offsetArg, offsetFP);
6034		6042
6035	root->appendNew<ControlValue>(proc, Return, Origin(), result);	6043	root->appendNewControlValue(proc, Return, Origin(), result);
6036	CHECK(compileAndRun<int64_t>(proc, 1, 2));	6044	CHECK(compileAndRun<int64_t>(proc, 1, 2));
6037	}	6045	}
6038	}	6046	}
Lines 6041-6047 void testStackSlot() Source/JavaScriptCore/b3/testb3.cpp_sec355
6041	{	6049	{
6042	Procedure proc;	6050	Procedure proc;
6043	BasicBlock* root = proc.addBlock();	6051	BasicBlock* root = proc.addBlock();
6044	root->appendNew<ControlValue>(	6052	root->appendNewControlValue(
6045	proc, Return, Origin(),	6053	proc, Return, Origin(),
6046	root->appendNew<SlotBaseValue>(proc, Origin(), proc.addStackSlot(1)));	6054	root->appendNew<SlotBaseValue>(proc, Origin(), proc.addStackSlot(1)));
6047		6055
Lines 6054-6060 void testLoadFromFramePointer() Source/JavaScriptCore/b3/testb3.cpp_sec356
6054	{	6062	{
6055	Procedure proc;	6063	Procedure proc;
6056	BasicBlock* root = proc.addBlock();	6064	BasicBlock* root = proc.addBlock();
6057	root->appendNew<ControlValue>(	6065	root->appendNewControlValue(
6058	proc, Return, Origin(),	6066	proc, Return, Origin(),
6059	root->appendNew<MemoryValue>(	6067	root->appendNew<MemoryValue>(
6060	proc, Load, pointerType(), Origin(),	6068	proc, Load, pointerType(), Origin(),
Lines 6081-6087 void testStoreLoadStackSlot(int value) Source/JavaScriptCore/b3/testb3.cpp_sec357
6081	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	6089	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
6082	stack);	6090	stack);
6083		6091
6084	root->appendNew<ControlValue>(	6092	root->appendNewControlValue(
6085	proc, Return, Origin(),	6093	proc, Return, Origin(),
6086	root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), stack));	6094	root->appendNew<MemoryValue>(proc, Load, Int32, Origin(), stack));
6087		6095
Lines 6116-6122 void testLoad(B3::Opcode opcode, InputTy Source/JavaScriptCore/b3/testb3.cpp_sec358
6116	Procedure proc;	6124	Procedure proc;
6117	BasicBlock* root = proc.addBlock();	6125	BasicBlock* root = proc.addBlock();
6118		6126
6119	root->appendNew<ControlValue>(	6127	root->appendNewControlValue(
6120	proc, Return, Origin(),	6128	proc, Return, Origin(),
6121	root->appendNew<MemoryValue>(	6129	root->appendNew<MemoryValue>(
6122	proc, opcode, type, Origin(),	6130	proc, opcode, type, Origin(),
Lines 6130-6136 void testLoad(B3::Opcode opcode, InputTy Source/JavaScriptCore/b3/testb3.cpp_sec359
6130	Procedure proc;	6138	Procedure proc;
6131	BasicBlock* root = proc.addBlock();	6139	BasicBlock* root = proc.addBlock();
6132		6140
6133	root->appendNew<ControlValue>(	6141	root->appendNewControlValue(
6134	proc, Return, Origin(),	6142	proc, Return, Origin(),
6135	root->appendNew<MemoryValue>(	6143	root->appendNew<MemoryValue>(
6136	proc, opcode, type, Origin(),	6144	proc, opcode, type, Origin(),
Lines 6144-6150 void testLoad(B3::Opcode opcode, InputTy Source/JavaScriptCore/b3/testb3.cpp_sec360
6144	Procedure proc;	6152	Procedure proc;
6145	BasicBlock* root = proc.addBlock();	6153	BasicBlock* root = proc.addBlock();
6146		6154
6147	root->appendNew<ControlValue>(	6155	root->appendNewControlValue(
6148	proc, Return, Origin(),	6156	proc, Return, Origin(),
6149	root->appendNew<MemoryValue>(	6157	root->appendNew<MemoryValue>(
6150	proc, opcode, type, Origin(),	6158	proc, opcode, type, Origin(),
Lines 6159-6165 void testLoad(B3::Opcode opcode, InputTy Source/JavaScriptCore/b3/testb3.cpp_sec361
6159	Procedure proc;	6167	Procedure proc;
6160	BasicBlock* root = proc.addBlock();	6168	BasicBlock* root = proc.addBlock();
6161		6169
6162	root->appendNew<ControlValue>(	6170	root->appendNewControlValue(
6163	proc, Return, Origin(),	6171	proc, Return, Origin(),
6164	root->appendNew<MemoryValue>(	6172	root->appendNew<MemoryValue>(
6165	proc, opcode, type, Origin(),	6173	proc, opcode, type, Origin(),
Lines 6179-6185 void testLoad(B3::Opcode opcode, InputTy Source/JavaScriptCore/b3/testb3.cpp_sec362
6179	Procedure proc;	6187	Procedure proc;
6180	BasicBlock* root = proc.addBlock();	6188	BasicBlock* root = proc.addBlock();
6181		6189
6182	root->appendNew<ControlValue>(	6190	root->appendNewControlValue(
6183	proc, Return, Origin(),	6191	proc, Return, Origin(),
6184	root->appendNew<MemoryValue>(	6192	root->appendNew<MemoryValue>(
6185	proc, opcode, type, Origin(),	6193	proc, opcode, type, Origin(),
Lines 6219-6225 void testStoreFloat(double input) Source/JavaScriptCore/b3/testb3.cpp_sec363
6219	Value* destinationAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	6227	Value* destinationAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
6220	root->appendNew<MemoryValue>(proc, Store, Origin(), argumentAsFloat, destinationAddress);	6228	root->appendNew<MemoryValue>(proc, Store, Origin(), argumentAsFloat, destinationAddress);
6221		6229
6222	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	6230	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
6223		6231
6224	float output = 0.;	6232	float output = 0.;
6225	CHECK(!compileAndRun<int64_t>(proc, input, &output));	6233	CHECK(!compileAndRun<int64_t>(proc, input, &output));
Lines 6243-6249 void testStoreFloat(double input) Source/JavaScriptCore/b3/testb3.cpp_sec364
6243		6251
6244	root->appendNew<MemoryValue>(proc, Store, Origin(), argumentAsFloat, destinationAddress);	6252	root->appendNew<MemoryValue>(proc, Store, Origin(), argumentAsFloat, destinationAddress);
6245		6253
6246	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	6254	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
6247		6255
6248	float output = 0.;	6256	float output = 0.;
6249	CHECK(!compileAndRun<int64_t>(proc, input, &output - 1, 1));	6257	CHECK(!compileAndRun<int64_t>(proc, input, &output - 1, 1));
Lines 6263-6269 void testStoreDoubleConstantAsFloat(doub Source/JavaScriptCore/b3/testb3.cpp_sec365
6263		6271
6264	root->appendNew<MemoryValue>(proc, Store, Origin(), valueAsFloat, destinationAddress);	6272	root->appendNew<MemoryValue>(proc, Store, Origin(), valueAsFloat, destinationAddress);
6265		6273
6266	root->appendNew<ControlValue>(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	6274	root->appendNewControlValue(proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
6267		6275
6268	float output = 0.;	6276	float output = 0.;
6269	CHECK(!compileAndRun<int64_t>(proc, input, &output));	6277	CHECK(!compileAndRun<int64_t>(proc, input, &output));
Lines 6289-6295 void testSpillGP() Source/JavaScriptCore/b3/testb3.cpp_sec366
6289	for (Value* value : sources)	6297	for (Value* value : sources)
6290	total = root->appendNew<Value>(proc, Add, Origin(), total, value);	6298	total = root->appendNew<Value>(proc, Add, Origin(), total, value);
6291		6299
6292	root->appendNew<ControlValue>(proc, Return, Origin(), total);	6300	root->appendNewControlValue(proc, Return, Origin(), total);
6293	compileAndRun<int>(proc, 1, 2);	6301	compileAndRun<int>(proc, 1, 2);
6294	}	6302	}
6295		6303
Lines 6312-6318 void testSpillFP() Source/JavaScriptCore/b3/testb3.cpp_sec367
6312	for (Value* value : sources)	6320	for (Value* value : sources)
6313	total = root->appendNew<Value>(proc, Add, Origin(), total, value);	6321	total = root->appendNew<Value>(proc, Add, Origin(), total, value);
6314		6322
6315	root->appendNew<ControlValue>(proc, Return, Origin(), total);	6323	root->appendNewControlValue(proc, Return, Origin(), total);
6316	compileAndRun<double>(proc, 1.1, 2.5);	6324	compileAndRun<double>(proc, 1.1, 2.5);
6317	}	6325	}
6318		6326
Lines 6328-6334 void testInt32ToDoublePartialRegisterSta Source/JavaScriptCore/b3/testb3.cpp_sec368
6328	Value* counter = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	6336	Value* counter = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
6329	UpsilonValue* originalTotal = root->appendNew<UpsilonValue>(proc, Origin(), total);	6337	UpsilonValue* originalTotal = root->appendNew<UpsilonValue>(proc, Origin(), total);
6330	UpsilonValue* originalCounter = root->appendNew<UpsilonValue>(proc, Origin(), counter);	6338	UpsilonValue* originalCounter = root->appendNew<UpsilonValue>(proc, Origin(), counter);
6331	root->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(loop));	6339	root->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(loop));
6332		6340
6333	// Loop.	6341	// Loop.
6334	Value* loopCounter = loop->appendNew<Value>(proc, Phi, Int64, Origin());	6342	Value* loopCounter = loop->appendNew<Value>(proc, Phi, Int64, Origin());
Lines 6345-6357 void testInt32ToDoublePartialRegisterSta Source/JavaScriptCore/b3/testb3.cpp_sec369
6345	Value* decCounter = loop->appendNew<Value>(proc, Sub, Origin(), loopCounter, loop->appendNew<Const64Value>(proc, Origin(), 1));	6353	Value* decCounter = loop->appendNew<Value>(proc, Sub, Origin(), loopCounter, loop->appendNew<Const64Value>(proc, Origin(), 1));
6346	UpsilonValue* decCounterUpsilon = loop->appendNew<UpsilonValue>(proc, Origin(), decCounter);	6354	UpsilonValue* decCounterUpsilon = loop->appendNew<UpsilonValue>(proc, Origin(), decCounter);
6347	decCounterUpsilon->setPhi(loopCounter);	6355	decCounterUpsilon->setPhi(loopCounter);
6348	loop->appendNew<ControlValue>(	6356	loop->appendNewControlValue(
6349	proc, Branch, Origin(),	6357	proc, Branch, Origin(),
6350	decCounter,	6358	decCounter,
6351	FrequentedBlock(loop), FrequentedBlock(done));	6359	FrequentedBlock(loop), FrequentedBlock(done));
6352		6360
6353	// Tail.	6361	// Tail.
6354	done->appendNew<ControlValue>(proc, Return, Origin(), updatedTotal);	6362	done->appendNewControlValue(proc, Return, Origin(), updatedTotal);
6355	CHECK(isIdentical(compileAndRun<double>(proc, 100000), 5000050000.));	6363	CHECK(isIdentical(compileAndRun<double>(proc, 100000), 5000050000.));
6356	}	6364	}
6357		6365
Lines 6371-6377 void testInt32ToDoublePartialRegisterWit Source/JavaScriptCore/b3/testb3.cpp_sec370
6371	Value* forPaddingInputAddress = root->appendNew<ConstPtrValue>(proc, Origin(), &forPaddingInput);	6379	Value* forPaddingInputAddress = root->appendNew<ConstPtrValue>(proc, Origin(), &forPaddingInput);
6372	uint64_t forPaddingOutput;	6380	uint64_t forPaddingOutput;
6373	Value* forPaddingOutputAddress = root->appendNew<ConstPtrValue>(proc, Origin(), &forPaddingOutput);	6381	Value* forPaddingOutputAddress = root->appendNew<ConstPtrValue>(proc, Origin(), &forPaddingOutput);
6374	root->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(loop));	6382	root->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(loop));
6375		6383
6376	// Loop.	6384	// Loop.
6377	Value* loopCounter = loop->appendNew<Value>(proc, Phi, Int64, Origin());	6385	Value* loopCounter = loop->appendNew<Value>(proc, Phi, Int64, Origin());
Lines 6405-6417 void testInt32ToDoublePartialRegisterWit Source/JavaScriptCore/b3/testb3.cpp_sec371
6405	Value* decCounter = loop->appendNew<Value>(proc, Sub, Origin(), loopCounter, loop->appendNew<Const64Value>(proc, Origin(), 1));	6413	Value* decCounter = loop->appendNew<Value>(proc, Sub, Origin(), loopCounter, loop->appendNew<Const64Value>(proc, Origin(), 1));
6406	UpsilonValue* decCounterUpsilon = loop->appendNew<UpsilonValue>(proc, Origin(), decCounter);	6414	UpsilonValue* decCounterUpsilon = loop->appendNew<UpsilonValue>(proc, Origin(), decCounter);
6407	decCounterUpsilon->setPhi(loopCounter);	6415	decCounterUpsilon->setPhi(loopCounter);
6408	loop->appendNew<ControlValue>(	6416	loop->appendNewControlValue(
6409	proc, Branch, Origin(),	6417	proc, Branch, Origin(),
6410	decCounter,	6418	decCounter,
6411	FrequentedBlock(loop), FrequentedBlock(done));	6419	FrequentedBlock(loop), FrequentedBlock(done));
6412		6420
6413	// Tail.	6421	// Tail.
6414	done->appendNew<ControlValue>(proc, Return, Origin(), updatedTotal);	6422	done->appendNewControlValue(proc, Return, Origin(), updatedTotal);
6415	CHECK(isIdentical(compileAndRun<double>(proc, 100000), 5000050000.));	6423	CHECK(isIdentical(compileAndRun<double>(proc, 100000), 5000050000.));
6416	}	6424	}
6417		6425
Lines 6422-6439 void testBranch() Source/JavaScriptCore/b3/testb3.cpp_sec372
6422	BasicBlock* thenCase = proc.addBlock();	6430	BasicBlock* thenCase = proc.addBlock();
6423	BasicBlock* elseCase = proc.addBlock();	6431	BasicBlock* elseCase = proc.addBlock();
6424		6432
6425	root->appendNew<ControlValue>(	6433	root->appendNewControlValue(
6426	proc, Branch, Origin(),	6434	proc, Branch, Origin(),
6427	root->appendNew<Value>(	6435	root->appendNew<Value>(
6428	proc, Trunc, Origin(),	6436	proc, Trunc, Origin(),
6429	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	6437	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
6430	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6438	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6431		6439
6432	thenCase->appendNew<ControlValue>(	6440	thenCase->appendNewControlValue(
6433	proc, Return, Origin(),	6441	proc, Return, Origin(),
6434	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	6442	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
6435		6443
6436	elseCase->appendNew<ControlValue>(	6444	elseCase->appendNewControlValue(
6437	proc, Return, Origin(),	6445	proc, Return, Origin(),
6438	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	6446	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
6439		6447
Lines 6449-6464 void testBranchPtr() Source/JavaScriptCore/b3/testb3.cpp_sec373
6449	BasicBlock* thenCase = proc.addBlock();	6457	BasicBlock* thenCase = proc.addBlock();
6450	BasicBlock* elseCase = proc.addBlock();	6458	BasicBlock* elseCase = proc.addBlock();
6451		6459
6452	root->appendNew<ControlValue>(	6460	root->appendNewControlValue(
6453	proc, Branch, Origin(),	6461	proc, Branch, Origin(),
6454	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	6462	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
6455	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6463	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6456		6464
6457	thenCase->appendNew<ControlValue>(	6465	thenCase->appendNewControlValue(
6458	proc, Return, Origin(),	6466	proc, Return, Origin(),
6459	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	6467	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
6460		6468
6461	elseCase->appendNew<ControlValue>(	6469	elseCase->appendNewControlValue(
6462	proc, Return, Origin(),	6470	proc, Return, Origin(),
6463	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	6471	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
6464		6472
Lines 6475-6481 void testDiamond() Source/JavaScriptCore/b3/testb3.cpp_sec374
6475	BasicBlock* elseCase = proc.addBlock();	6483	BasicBlock* elseCase = proc.addBlock();
6476	BasicBlock* done = proc.addBlock();	6484	BasicBlock* done = proc.addBlock();
6477		6485
6478	root->appendNew<ControlValue>(	6486	root->appendNewControlValue(
6479	proc, Branch, Origin(),	6487	proc, Branch, Origin(),
6480	root->appendNew<Value>(	6488	root->appendNew<Value>(
6481	proc, Trunc, Origin(),	6489	proc, Trunc, Origin(),
Lines 6484-6499 void testDiamond() Source/JavaScriptCore/b3/testb3.cpp_sec375
6484		6492
6485	UpsilonValue* thenResult = thenCase->appendNew<UpsilonValue>(	6493	UpsilonValue* thenResult = thenCase->appendNew<UpsilonValue>(
6486	proc, Origin(), thenCase->appendNew<Const32Value>(proc, Origin(), 1));	6494	proc, Origin(), thenCase->appendNew<Const32Value>(proc, Origin(), 1));
6487	thenCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(done));	6495	thenCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(done));
6488		6496
6489	UpsilonValue* elseResult = elseCase->appendNew<UpsilonValue>(	6497	UpsilonValue* elseResult = elseCase->appendNew<UpsilonValue>(
6490	proc, Origin(), elseCase->appendNew<Const32Value>(proc, Origin(), 0));	6498	proc, Origin(), elseCase->appendNew<Const32Value>(proc, Origin(), 0));
6491	elseCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(done));	6499	elseCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(done));
6492		6500
6493	Value* phi = done->appendNew<Value>(proc, Phi, Int32, Origin());	6501	Value* phi = done->appendNew<Value>(proc, Phi, Int32, Origin());
6494	thenResult->setPhi(phi);	6502	thenResult->setPhi(phi);
6495	elseResult->setPhi(phi);	6503	elseResult->setPhi(phi);
6496	done->appendNew<ControlValue>(proc, Return, Origin(), phi);	6504	done->appendNewControlValue(proc, Return, Origin(), phi);
6497		6505
6498	auto code = compile(proc);	6506	auto code = compile(proc);
6499	CHECK(invoke<int>(*code, 42) == 1);	6507	CHECK(invoke<int>(*code, 42) == 1);
Lines 6507-6513 void testBranchNotEqual() Source/JavaScriptCore/b3/testb3.cpp_sec376
6507	BasicBlock* thenCase = proc.addBlock();	6515	BasicBlock* thenCase = proc.addBlock();
6508	BasicBlock* elseCase = proc.addBlock();	6516	BasicBlock* elseCase = proc.addBlock();
6509		6517
6510	root->appendNew<ControlValue>(	6518	root->appendNewControlValue(
6511	proc, Branch, Origin(),	6519	proc, Branch, Origin(),
6512	root->appendNew<Value>(	6520	root->appendNew<Value>(
6513	proc, NotEqual, Origin(),	6521	proc, NotEqual, Origin(),
Lines 6517-6527 void testBranchNotEqual() Source/JavaScriptCore/b3/testb3.cpp_sec377
6517	root->appendNew<Const32Value>(proc, Origin(), 0)),	6525	root->appendNew<Const32Value>(proc, Origin(), 0)),
6518	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6526	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6519		6527
6520	thenCase->appendNew<ControlValue>(	6528	thenCase->appendNewControlValue(
6521	proc, Return, Origin(),	6529	proc, Return, Origin(),
6522	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	6530	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
6523		6531
6524	elseCase->appendNew<ControlValue>(	6532	elseCase->appendNewControlValue(
6525	proc, Return, Origin(),	6533	proc, Return, Origin(),
6526	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	6534	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
6527		6535
Lines 6537-6543 void testBranchNotEqualCommute() Source/JavaScriptCore/b3/testb3.cpp_sec378
6537	BasicBlock* thenCase = proc.addBlock();	6545	BasicBlock* thenCase = proc.addBlock();
6538	BasicBlock* elseCase = proc.addBlock();	6546	BasicBlock* elseCase = proc.addBlock();
6539		6547
6540	root->appendNew<ControlValue>(	6548	root->appendNewControlValue(
6541	proc, Branch, Origin(),	6549	proc, Branch, Origin(),
6542	root->appendNew<Value>(	6550	root->appendNew<Value>(
6543	proc, NotEqual, Origin(),	6551	proc, NotEqual, Origin(),
Lines 6547-6557 void testBranchNotEqualCommute() Source/JavaScriptCore/b3/testb3.cpp_sec379
6547	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),	6555	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
6548	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6556	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6549		6557
6550	thenCase->appendNew<ControlValue>(	6558	thenCase->appendNewControlValue(
6551	proc, Return, Origin(),	6559	proc, Return, Origin(),
6552	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	6560	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
6553		6561
6554	elseCase->appendNew<ControlValue>(	6562	elseCase->appendNewControlValue(
6555	proc, Return, Origin(),	6563	proc, Return, Origin(),
6556	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	6564	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
6557		6565
Lines 6567-6573 void testBranchNotEqualNotEqual() Source/JavaScriptCore/b3/testb3.cpp_sec380
6567	BasicBlock* thenCase = proc.addBlock();	6575	BasicBlock* thenCase = proc.addBlock();
6568	BasicBlock* elseCase = proc.addBlock();	6576	BasicBlock* elseCase = proc.addBlock();
6569		6577
6570	root->appendNew<ControlValue>(	6578	root->appendNewControlValue(
6571	proc, Branch, Origin(),	6579	proc, Branch, Origin(),
6572	root->appendNew<Value>(	6580	root->appendNew<Value>(
6573	proc, NotEqual, Origin(),	6581	proc, NotEqual, Origin(),
Lines 6580-6590 void testBranchNotEqualNotEqual() Source/JavaScriptCore/b3/testb3.cpp_sec381
6580	root->appendNew<Const32Value>(proc, Origin(), 0)),	6588	root->appendNew<Const32Value>(proc, Origin(), 0)),
6581	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6589	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6582		6590
6583	thenCase->appendNew<ControlValue>(	6591	thenCase->appendNewControlValue(
6584	proc, Return, Origin(),	6592	proc, Return, Origin(),
6585	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	6593	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
6586		6594
6587	elseCase->appendNew<ControlValue>(	6595	elseCase->appendNewControlValue(
6588	proc, Return, Origin(),	6596	proc, Return, Origin(),
6589	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	6597	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
6590		6598
Lines 6600-6606 void testBranchEqual() Source/JavaScriptCore/b3/testb3.cpp_sec382
6600	BasicBlock* thenCase = proc.addBlock();	6608	BasicBlock* thenCase = proc.addBlock();
6601	BasicBlock* elseCase = proc.addBlock();	6609	BasicBlock* elseCase = proc.addBlock();
6602		6610
6603	root->appendNew<ControlValue>(	6611	root->appendNewControlValue(
6604	proc, Branch, Origin(),	6612	proc, Branch, Origin(),
6605	root->appendNew<Value>(	6613	root->appendNew<Value>(
6606	proc, Equal, Origin(),	6614	proc, Equal, Origin(),
Lines 6610-6620 void testBranchEqual() Source/JavaScriptCore/b3/testb3.cpp_sec383
6610	root->appendNew<Const32Value>(proc, Origin(), 0)),	6618	root->appendNew<Const32Value>(proc, Origin(), 0)),
6611	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6619	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6612		6620
6613	thenCase->appendNew<ControlValue>(	6621	thenCase->appendNewControlValue(
6614	proc, Return, Origin(),	6622	proc, Return, Origin(),
6615	thenCase->appendNew<Const32Value>(proc, Origin(), 0));	6623	thenCase->appendNew<Const32Value>(proc, Origin(), 0));
6616		6624
6617	elseCase->appendNew<ControlValue>(	6625	elseCase->appendNewControlValue(
6618	proc, Return, Origin(),	6626	proc, Return, Origin(),
6619	elseCase->appendNew<Const32Value>(proc, Origin(), 1));	6627	elseCase->appendNew<Const32Value>(proc, Origin(), 1));
6620		6628
Lines 6630-6636 void testBranchEqualEqual() Source/JavaScriptCore/b3/testb3.cpp_sec384
6630	BasicBlock* thenCase = proc.addBlock();	6638	BasicBlock* thenCase = proc.addBlock();
6631	BasicBlock* elseCase = proc.addBlock();	6639	BasicBlock* elseCase = proc.addBlock();
6632		6640
6633	root->appendNew<ControlValue>(	6641	root->appendNewControlValue(
6634	proc, Branch, Origin(),	6642	proc, Branch, Origin(),
6635	root->appendNew<Value>(	6643	root->appendNew<Value>(
6636	proc, Equal, Origin(),	6644	proc, Equal, Origin(),
Lines 6643-6653 void testBranchEqualEqual() Source/JavaScriptCore/b3/testb3.cpp_sec385
6643	root->appendNew<Const32Value>(proc, Origin(), 0)),	6651	root->appendNew<Const32Value>(proc, Origin(), 0)),
6644	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6652	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6645		6653
6646	thenCase->appendNew<ControlValue>(	6654	thenCase->appendNewControlValue(
6647	proc, Return, Origin(),	6655	proc, Return, Origin(),
6648	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	6656	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
6649		6657
6650	elseCase->appendNew<ControlValue>(	6658	elseCase->appendNewControlValue(
6651	proc, Return, Origin(),	6659	proc, Return, Origin(),
6652	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	6660	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
6653		6661
Lines 6663-6669 void testBranchEqualCommute() Source/JavaScriptCore/b3/testb3.cpp_sec386
6663	BasicBlock* thenCase = proc.addBlock();	6671	BasicBlock* thenCase = proc.addBlock();
6664	BasicBlock* elseCase = proc.addBlock();	6672	BasicBlock* elseCase = proc.addBlock();
6665		6673
6666	root->appendNew<ControlValue>(	6674	root->appendNewControlValue(
6667	proc, Branch, Origin(),	6675	proc, Branch, Origin(),
6668	root->appendNew<Value>(	6676	root->appendNew<Value>(
6669	proc, Equal, Origin(),	6677	proc, Equal, Origin(),
Lines 6673-6683 void testBranchEqualCommute() Source/JavaScriptCore/b3/testb3.cpp_sec387
6673	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),	6681	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))),
6674	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6682	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6675		6683
6676	thenCase->appendNew<ControlValue>(	6684	thenCase->appendNewControlValue(
6677	proc, Return, Origin(),	6685	proc, Return, Origin(),
6678	thenCase->appendNew<Const32Value>(proc, Origin(), 0));	6686	thenCase->appendNew<Const32Value>(proc, Origin(), 0));
6679		6687
6680	elseCase->appendNew<ControlValue>(	6688	elseCase->appendNewControlValue(
6681	proc, Return, Origin(),	6689	proc, Return, Origin(),
6682	elseCase->appendNew<Const32Value>(proc, Origin(), 1));	6690	elseCase->appendNew<Const32Value>(proc, Origin(), 1));
6683		6691
Lines 6693-6699 void testBranchEqualEqual1() Source/JavaScriptCore/b3/testb3.cpp_sec388
6693	BasicBlock* thenCase = proc.addBlock();	6701	BasicBlock* thenCase = proc.addBlock();
6694	BasicBlock* elseCase = proc.addBlock();	6702	BasicBlock* elseCase = proc.addBlock();
6695		6703
6696	root->appendNew<ControlValue>(	6704	root->appendNewControlValue(
6697	proc, Branch, Origin(),	6705	proc, Branch, Origin(),
6698	root->appendNew<Value>(	6706	root->appendNew<Value>(
6699	proc, Equal, Origin(),	6707	proc, Equal, Origin(),
Lines 6706-6716 void testBranchEqualEqual1() Source/JavaScriptCore/b3/testb3.cpp_sec389
6706	root->appendNew<Const32Value>(proc, Origin(), 1)),	6714	root->appendNew<Const32Value>(proc, Origin(), 1)),
6707	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6715	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6708		6716
6709	thenCase->appendNew<ControlValue>(	6717	thenCase->appendNewControlValue(
6710	proc, Return, Origin(),	6718	proc, Return, Origin(),
6711	thenCase->appendNew<Const32Value>(proc, Origin(), 0));	6719	thenCase->appendNew<Const32Value>(proc, Origin(), 0));
6712		6720
6713	elseCase->appendNew<ControlValue>(	6721	elseCase->appendNewControlValue(
6714	proc, Return, Origin(),	6722	proc, Return, Origin(),
6715	elseCase->appendNew<Const32Value>(proc, Origin(), 1));	6723	elseCase->appendNew<Const32Value>(proc, Origin(), 1));
6716		6724
Lines 6728-6734 void testBranchEqualOrUnorderedArgs(doub Source/JavaScriptCore/b3/testb3.cpp_sec390
6728		6736
6729	Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	6737	Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
6730	Value* argumentB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);	6738	Value* argumentB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
6731	root->appendNew<ControlValue>(	6739	root->appendNewControlValue(
6732	proc, Branch, Origin(),	6740	proc, Branch, Origin(),
6733	root->appendNew<Value>(	6741	root->appendNew<Value>(
6734	proc, EqualOrUnordered, Origin(),	6742	proc, EqualOrUnordered, Origin(),
Lines 6736-6746 void testBranchEqualOrUnorderedArgs(doub Source/JavaScriptCore/b3/testb3.cpp_sec391
6736	argumentB),	6744	argumentB),
6737	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6745	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6738		6746
6739	thenCase->appendNew<ControlValue>(	6747	thenCase->appendNewControlValue(
6740	proc, Return, Origin(),	6748	proc, Return, Origin(),
6741	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	6749	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
6742		6750
6743	elseCase->appendNew<ControlValue>(	6751	elseCase->appendNewControlValue(
6744	proc, Return, Origin(),	6752	proc, Return, Origin(),
6745	elseCase->appendNew<Const32Value>(proc, Origin(), -13));	6753	elseCase->appendNew<Const32Value>(proc, Origin(), -13));
6746		6754
Lines 6760-6766 void testBranchEqualOrUnorderedArgs(floa Source/JavaScriptCore/b3/testb3.cpp_sec392
6760	Value* argumentB = root->appendNew<MemoryValue>(proc, Load, Float, Origin(),	6768	Value* argumentB = root->appendNew<MemoryValue>(proc, Load, Float, Origin(),
6761	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	6769	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
6762		6770
6763	root->appendNew<ControlValue>(	6771	root->appendNewControlValue(
6764	proc, Branch, Origin(),	6772	proc, Branch, Origin(),
6765	root->appendNew<Value>(	6773	root->appendNew<Value>(
6766	proc, EqualOrUnordered, Origin(),	6774	proc, EqualOrUnordered, Origin(),
Lines 6768-6778 void testBranchEqualOrUnorderedArgs(floa Source/JavaScriptCore/b3/testb3.cpp_sec393
6768	argumentB),	6776	argumentB),
6769	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6777	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6770		6778
6771	thenCase->appendNew<ControlValue>(	6779	thenCase->appendNewControlValue(
6772	proc, Return, Origin(),	6780	proc, Return, Origin(),
6773	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	6781	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
6774		6782
6775	elseCase->appendNew<ControlValue>(	6783	elseCase->appendNewControlValue(
6776	proc, Return, Origin(),	6784	proc, Return, Origin(),
6777	elseCase->appendNew<Const32Value>(proc, Origin(), -13));	6785	elseCase->appendNew<Const32Value>(proc, Origin(), -13));
6778		6786
Lines 6797-6812 void testBranchNotEqualAndOrderedArgs(do Source/JavaScriptCore/b3/testb3.cpp_sec394
6797	proc, Equal, Origin(),	6805	proc, Equal, Origin(),
6798	root->appendNew<Const32Value>(proc, Origin(), 0),	6806	root->appendNew<Const32Value>(proc, Origin(), 0),
6799	equalOrUnordered);	6807	equalOrUnordered);
6800	root->appendNew<ControlValue>(	6808	root->appendNewControlValue(
6801	proc, Branch, Origin(),	6809	proc, Branch, Origin(),
6802	notEqualAndOrdered,	6810	notEqualAndOrdered,
6803	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6811	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6804		6812
6805	thenCase->appendNew<ControlValue>(	6813	thenCase->appendNewControlValue(
6806	proc, Return, Origin(),	6814	proc, Return, Origin(),
6807	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	6815	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
6808		6816
6809	elseCase->appendNew<ControlValue>(	6817	elseCase->appendNewControlValue(
6810	proc, Return, Origin(),	6818	proc, Return, Origin(),
6811	elseCase->appendNew<Const32Value>(proc, Origin(), -13));	6819	elseCase->appendNew<Const32Value>(proc, Origin(), -13));
6812		6820
Lines 6833-6848 void testBranchNotEqualAndOrderedArgs(fl Source/JavaScriptCore/b3/testb3.cpp_sec395
6833	proc, Equal, Origin(),	6841	proc, Equal, Origin(),
6834	root->appendNew<Const32Value>(proc, Origin(), 0),	6842	root->appendNew<Const32Value>(proc, Origin(), 0),
6835	equalOrUnordered);	6843	equalOrUnordered);
6836	root->appendNew<ControlValue>(	6844	root->appendNewControlValue(
6837	proc, Branch, Origin(),	6845	proc, Branch, Origin(),
6838	notEqualAndOrdered,	6846	notEqualAndOrdered,
6839	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6847	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6840		6848
6841	thenCase->appendNew<ControlValue>(	6849	thenCase->appendNewControlValue(
6842	proc, Return, Origin(),	6850	proc, Return, Origin(),
6843	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	6851	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
6844		6852
6845	elseCase->appendNew<ControlValue>(	6853	elseCase->appendNewControlValue(
6846	proc, Return, Origin(),	6854	proc, Return, Origin(),
6847	elseCase->appendNew<Const32Value>(proc, Origin(), -13));	6855	elseCase->appendNew<Const32Value>(proc, Origin(), -13));
6848		6856
Lines 6859-6865 void testBranchEqualOrUnorderedDoubleArg Source/JavaScriptCore/b3/testb3.cpp_sec396
6859		6867
6860	Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);	6868	Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
6861	Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	6869	Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
6862	root->appendNew<ControlValue>(	6870	root->appendNewControlValue(
6863	proc, Branch, Origin(),	6871	proc, Branch, Origin(),
6864	root->appendNew<Value>(	6872	root->appendNew<Value>(
6865	proc, EqualOrUnordered, Origin(),	6873	proc, EqualOrUnordered, Origin(),
Lines 6867-6877 void testBranchEqualOrUnorderedDoubleArg Source/JavaScriptCore/b3/testb3.cpp_sec397
6867	argumentB),	6875	argumentB),
6868	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6876	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6869		6877
6870	thenCase->appendNew<ControlValue>(	6878	thenCase->appendNewControlValue(
6871	proc, Return, Origin(),	6879	proc, Return, Origin(),
6872	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	6880	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
6873		6881
6874	elseCase->appendNew<ControlValue>(	6882	elseCase->appendNewControlValue(
6875	proc, Return, Origin(),	6883	proc, Return, Origin(),
6876	elseCase->appendNew<Const32Value>(proc, Origin(), -13));	6884	elseCase->appendNew<Const32Value>(proc, Origin(), -13));
6877		6885
Lines 6890-6896 void testBranchEqualOrUnorderedFloatArgI Source/JavaScriptCore/b3/testb3.cpp_sec398
6890	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	6898	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
6891	Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);	6899	Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);
6892		6900
6893	root->appendNew<ControlValue>(	6901	root->appendNewControlValue(
6894	proc, Branch, Origin(),	6902	proc, Branch, Origin(),
6895	root->appendNew<Value>(	6903	root->appendNew<Value>(
6896	proc, EqualOrUnordered, Origin(),	6904	proc, EqualOrUnordered, Origin(),
Lines 6898-6908 void testBranchEqualOrUnorderedFloatArgI Source/JavaScriptCore/b3/testb3.cpp_sec399
6898	argumentB),	6906	argumentB),
6899	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6907	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6900		6908
6901	thenCase->appendNew<ControlValue>(	6909	thenCase->appendNewControlValue(
6902	proc, Return, Origin(),	6910	proc, Return, Origin(),
6903	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	6911	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
6904		6912
6905	elseCase->appendNew<ControlValue>(	6913	elseCase->appendNewControlValue(
6906	proc, Return, Origin(),	6914	proc, Return, Origin(),
6907	elseCase->appendNew<Const32Value>(proc, Origin(), -13));	6915	elseCase->appendNew<Const32Value>(proc, Origin(), -13));
6908		6916
Lines 6919-6925 void testBranchEqualOrUnorderedDoubleImm Source/JavaScriptCore/b3/testb3.cpp_sec400
6919		6927
6920	Value* argumentA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);	6928	Value* argumentA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
6921	Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);	6929	Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
6922	root->appendNew<ControlValue>(	6930	root->appendNewControlValue(
6923	proc, Branch, Origin(),	6931	proc, Branch, Origin(),
6924	root->appendNew<Value>(	6932	root->appendNew<Value>(
6925	proc, EqualOrUnordered, Origin(),	6933	proc, EqualOrUnordered, Origin(),
Lines 6927-6937 void testBranchEqualOrUnorderedDoubleImm Source/JavaScriptCore/b3/testb3.cpp_sec401
6927	argumentB),	6935	argumentB),
6928	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6936	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6929		6937
6930	thenCase->appendNew<ControlValue>(	6938	thenCase->appendNewControlValue(
6931	proc, Return, Origin(),	6939	proc, Return, Origin(),
6932	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	6940	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
6933		6941
6934	elseCase->appendNew<ControlValue>(	6942	elseCase->appendNewControlValue(
6935	proc, Return, Origin(),	6943	proc, Return, Origin(),
6936	elseCase->appendNew<Const32Value>(proc, Origin(), -13));	6944	elseCase->appendNew<Const32Value>(proc, Origin(), -13));
6937		6945
Lines 6949-6955 void testBranchEqualOrUnorderedFloatImms Source/JavaScriptCore/b3/testb3.cpp_sec402
6949	Value* argumentA = root->appendNew<ConstFloatValue>(proc, Origin(), a);	6957	Value* argumentA = root->appendNew<ConstFloatValue>(proc, Origin(), a);
6950	Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);	6958	Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);
6951		6959
6952	root->appendNew<ControlValue>(	6960	root->appendNewControlValue(
6953	proc, Branch, Origin(),	6961	proc, Branch, Origin(),
6954	root->appendNew<Value>(	6962	root->appendNew<Value>(
6955	proc, EqualOrUnordered, Origin(),	6963	proc, EqualOrUnordered, Origin(),
Lines 6957-6967 void testBranchEqualOrUnorderedFloatImms Source/JavaScriptCore/b3/testb3.cpp_sec403
6957	argumentB),	6965	argumentB),
6958	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	6966	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6959		6967
6960	thenCase->appendNew<ControlValue>(	6968	thenCase->appendNewControlValue(
6961	proc, Return, Origin(),	6969	proc, Return, Origin(),
6962	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	6970	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
6963		6971
6964	elseCase->appendNew<ControlValue>(	6972	elseCase->appendNewControlValue(
6965	proc, Return, Origin(),	6973	proc, Return, Origin(),
6966	elseCase->appendNew<Const32Value>(proc, Origin(), -13));	6974	elseCase->appendNew<Const32Value>(proc, Origin(), -13));
6967		6975
Lines 6983-6989 void testBranchEqualOrUnorderedFloatWith Source/JavaScriptCore/b3/testb3.cpp_sec404
6983	Value* argument1AsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argument1);	6991	Value* argument1AsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argument1);
6984	Value* argument2AsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argument2);	6992	Value* argument2AsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argument2);
6985		6993
6986	root->appendNew<ControlValue>(	6994	root->appendNewControlValue(
6987	proc, Branch, Origin(),	6995	proc, Branch, Origin(),
6988	root->appendNew<Value>(	6996	root->appendNew<Value>(
6989	proc, EqualOrUnordered, Origin(),	6997	proc, EqualOrUnordered, Origin(),
Lines 6991-7001 void testBranchEqualOrUnorderedFloatWith Source/JavaScriptCore/b3/testb3.cpp_sec405
6991	argument2AsDouble),	6999	argument2AsDouble),
6992	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7000	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
6993		7001
6994	thenCase->appendNew<ControlValue>(	7002	thenCase->appendNewControlValue(
6995	proc, Return, Origin(),	7003	proc, Return, Origin(),
6996	thenCase->appendNew<Const32Value>(proc, Origin(), 42));	7004	thenCase->appendNew<Const32Value>(proc, Origin(), 42));
6997		7005
6998	elseCase->appendNew<ControlValue>(	7006	elseCase->appendNewControlValue(
6999	proc, Return, Origin(),	7007	proc, Return, Origin(),
7000	elseCase->appendNew<Const32Value>(proc, Origin(), -13));	7008	elseCase->appendNew<Const32Value>(proc, Origin(), -13));
7001		7009
Lines 7010-7025 void testBranchFold(int value) Source/JavaScriptCore/b3/testb3.cpp_sec406
7010	BasicBlock* thenCase = proc.addBlock();	7018	BasicBlock* thenCase = proc.addBlock();
7011	BasicBlock* elseCase = proc.addBlock();	7019	BasicBlock* elseCase = proc.addBlock();
7012		7020
7013	root->appendNew<ControlValue>(	7021	root->appendNewControlValue(
7014	proc, Branch, Origin(),	7022	proc, Branch, Origin(),
7015	root->appendNew<Const32Value>(proc, Origin(), value),	7023	root->appendNew<Const32Value>(proc, Origin(), value),
7016	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7024	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7017		7025
7018	thenCase->appendNew<ControlValue>(	7026	thenCase->appendNewControlValue(
7019	proc, Return, Origin(),	7027	proc, Return, Origin(),
7020	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7028	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7021		7029
7022	elseCase->appendNew<ControlValue>(	7030	elseCase->appendNewControlValue(
7023	proc, Return, Origin(),	7031	proc, Return, Origin(),
7024	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7032	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7025		7033
Lines 7034-7056 void testDiamondFold(int value) Source/JavaScriptCore/b3/testb3.cpp_sec407
7034	BasicBlock* elseCase = proc.addBlock();	7042	BasicBlock* elseCase = proc.addBlock();
7035	BasicBlock* done = proc.addBlock();	7043	BasicBlock* done = proc.addBlock();
7036		7044
7037	root->appendNew<ControlValue>(	7045	root->appendNewControlValue(
7038	proc, Branch, Origin(),	7046	proc, Branch, Origin(),
7039	root->appendNew<Const32Value>(proc, Origin(), value),	7047	root->appendNew<Const32Value>(proc, Origin(), value),
7040	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7048	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7041		7049
7042	UpsilonValue* thenResult = thenCase->appendNew<UpsilonValue>(	7050	UpsilonValue* thenResult = thenCase->appendNew<UpsilonValue>(
7043	proc, Origin(), thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7051	proc, Origin(), thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7044	thenCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(done));	7052	thenCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(done));
7045		7053
7046	UpsilonValue* elseResult = elseCase->appendNew<UpsilonValue>(	7054	UpsilonValue* elseResult = elseCase->appendNew<UpsilonValue>(
7047	proc, Origin(), elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7055	proc, Origin(), elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7048	elseCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(done));	7056	elseCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(done));
7049		7057
7050	Value* phi = done->appendNew<Value>(proc, Phi, Int32, Origin());	7058	Value* phi = done->appendNew<Value>(proc, Phi, Int32, Origin());
7051	thenResult->setPhi(phi);	7059	thenResult->setPhi(phi);
7052	elseResult->setPhi(phi);	7060	elseResult->setPhi(phi);
7053	done->appendNew<ControlValue>(proc, Return, Origin(), phi);	7061	done->appendNewControlValue(proc, Return, Origin(), phi);
7054		7062
7055	CHECK(compileAndRun<int>(proc) == !!value);	7063	CHECK(compileAndRun<int>(proc) == !!value);
7056	}	7064	}
Lines 7062-7068 void testBranchNotEqualFoldPtr(intptr_t Source/JavaScriptCore/b3/testb3.cpp_sec408
7062	BasicBlock* thenCase = proc.addBlock();	7070	BasicBlock* thenCase = proc.addBlock();
7063	BasicBlock* elseCase = proc.addBlock();	7071	BasicBlock* elseCase = proc.addBlock();
7064		7072
7065	root->appendNew<ControlValue>(	7073	root->appendNewControlValue(
7066	proc, Branch, Origin(),	7074	proc, Branch, Origin(),
7067	root->appendNew<Value>(	7075	root->appendNew<Value>(
7068	proc, NotEqual, Origin(),	7076	proc, NotEqual, Origin(),
Lines 7070-7080 void testBranchNotEqualFoldPtr(intptr_t Source/JavaScriptCore/b3/testb3.cpp_sec409
7070	root->appendNew<ConstPtrValue>(proc, Origin(), 0)),	7078	root->appendNew<ConstPtrValue>(proc, Origin(), 0)),
7071	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7079	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7072		7080
7073	thenCase->appendNew<ControlValue>(	7081	thenCase->appendNewControlValue(
7074	proc, Return, Origin(),	7082	proc, Return, Origin(),
7075	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7083	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7076		7084
7077	elseCase->appendNew<ControlValue>(	7085	elseCase->appendNewControlValue(
7078	proc, Return, Origin(),	7086	proc, Return, Origin(),
7079	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7087	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7080		7088
Lines 7088-7094 void testBranchEqualFoldPtr(intptr_t val Source/JavaScriptCore/b3/testb3.cpp_sec410
7088	BasicBlock* thenCase = proc.addBlock();	7096	BasicBlock* thenCase = proc.addBlock();
7089	BasicBlock* elseCase = proc.addBlock();	7097	BasicBlock* elseCase = proc.addBlock();
7090		7098
7091	root->appendNew<ControlValue>(	7099	root->appendNewControlValue(
7092	proc, Branch, Origin(),	7100	proc, Branch, Origin(),
7093	root->appendNew<Value>(	7101	root->appendNew<Value>(
7094	proc, Equal, Origin(),	7102	proc, Equal, Origin(),
Lines 7096-7106 void testBranchEqualFoldPtr(intptr_t val Source/JavaScriptCore/b3/testb3.cpp_sec411
7096	root->appendNew<ConstPtrValue>(proc, Origin(), 0)),	7104	root->appendNew<ConstPtrValue>(proc, Origin(), 0)),
7097	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7105	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7098		7106
7099	thenCase->appendNew<ControlValue>(	7107	thenCase->appendNewControlValue(
7100	proc, Return, Origin(),	7108	proc, Return, Origin(),
7101	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7109	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7102		7110
7103	elseCase->appendNew<ControlValue>(	7111	elseCase->appendNewControlValue(
7104	proc, Return, Origin(),	7112	proc, Return, Origin(),
7105	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7113	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7106		7114
Lines 7114-7131 void testBranchLoadPtr() Source/JavaScriptCore/b3/testb3.cpp_sec412
7114	BasicBlock* thenCase = proc.addBlock();	7122	BasicBlock* thenCase = proc.addBlock();
7115	BasicBlock* elseCase = proc.addBlock();	7123	BasicBlock* elseCase = proc.addBlock();
7116		7124
7117	root->appendNew<ControlValue>(	7125	root->appendNewControlValue(
7118	proc, Branch, Origin(),	7126	proc, Branch, Origin(),
7119	root->appendNew<MemoryValue>(	7127	root->appendNew<MemoryValue>(
7120	proc, Load, pointerType(), Origin(),	7128	proc, Load, pointerType(), Origin(),
7121	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	7129	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
7122	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7130	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7123		7131
7124	thenCase->appendNew<ControlValue>(	7132	thenCase->appendNewControlValue(
7125	proc, Return, Origin(),	7133	proc, Return, Origin(),
7126	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7134	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7127		7135
7128	elseCase->appendNew<ControlValue>(	7136	elseCase->appendNewControlValue(
7129	proc, Return, Origin(),	7137	proc, Return, Origin(),
7130	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7138	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7131		7139
Lines 7144-7161 void testBranchLoad32() Source/JavaScriptCore/b3/testb3.cpp_sec413
7144	BasicBlock* thenCase = proc.addBlock();	7152	BasicBlock* thenCase = proc.addBlock();
7145	BasicBlock* elseCase = proc.addBlock();	7153	BasicBlock* elseCase = proc.addBlock();
7146		7154
7147	root->appendNew<ControlValue>(	7155	root->appendNewControlValue(
7148	proc, Branch, Origin(),	7156	proc, Branch, Origin(),
7149	root->appendNew<MemoryValue>(	7157	root->appendNew<MemoryValue>(
7150	proc, Load, Int32, Origin(),	7158	proc, Load, Int32, Origin(),
7151	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	7159	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
7152	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7160	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7153		7161
7154	thenCase->appendNew<ControlValue>(	7162	thenCase->appendNewControlValue(
7155	proc, Return, Origin(),	7163	proc, Return, Origin(),
7156	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7164	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7157		7165
7158	elseCase->appendNew<ControlValue>(	7166	elseCase->appendNewControlValue(
7159	proc, Return, Origin(),	7167	proc, Return, Origin(),
7160	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7168	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7161		7169
Lines 7174-7191 void testBranchLoad8S() Source/JavaScriptCore/b3/testb3.cpp_sec414
7174	BasicBlock* thenCase = proc.addBlock();	7182	BasicBlock* thenCase = proc.addBlock();
7175	BasicBlock* elseCase = proc.addBlock();	7183	BasicBlock* elseCase = proc.addBlock();
7176		7184
7177	root->appendNew<ControlValue>(	7185	root->appendNewControlValue(
7178	proc, Branch, Origin(),	7186	proc, Branch, Origin(),
7179	root->appendNew<MemoryValue>(	7187	root->appendNew<MemoryValue>(
7180	proc, Load8S, Origin(),	7188	proc, Load8S, Origin(),
7181	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	7189	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
7182	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7190	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7183		7191
7184	thenCase->appendNew<ControlValue>(	7192	thenCase->appendNewControlValue(
7185	proc, Return, Origin(),	7193	proc, Return, Origin(),
7186	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7194	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7187		7195
7188	elseCase->appendNew<ControlValue>(	7196	elseCase->appendNewControlValue(
7189	proc, Return, Origin(),	7197	proc, Return, Origin(),
7190	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7198	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7191		7199
Lines 7204-7221 void testBranchLoad8Z() Source/JavaScriptCore/b3/testb3.cpp_sec415
7204	BasicBlock* thenCase = proc.addBlock();	7212	BasicBlock* thenCase = proc.addBlock();
7205	BasicBlock* elseCase = proc.addBlock();	7213	BasicBlock* elseCase = proc.addBlock();
7206		7214
7207	root->appendNew<ControlValue>(	7215	root->appendNewControlValue(
7208	proc, Branch, Origin(),	7216	proc, Branch, Origin(),
7209	root->appendNew<MemoryValue>(	7217	root->appendNew<MemoryValue>(
7210	proc, Load8Z, Origin(),	7218	proc, Load8Z, Origin(),
7211	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	7219	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
7212	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7220	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7213		7221
7214	thenCase->appendNew<ControlValue>(	7222	thenCase->appendNewControlValue(
7215	proc, Return, Origin(),	7223	proc, Return, Origin(),
7216	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7224	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7217		7225
7218	elseCase->appendNew<ControlValue>(	7226	elseCase->appendNewControlValue(
7219	proc, Return, Origin(),	7227	proc, Return, Origin(),
7220	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7228	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7221		7229
Lines 7234-7251 void testBranchLoad16S() Source/JavaScriptCore/b3/testb3.cpp_sec416
7234	BasicBlock* thenCase = proc.addBlock();	7242	BasicBlock* thenCase = proc.addBlock();
7235	BasicBlock* elseCase = proc.addBlock();	7243	BasicBlock* elseCase = proc.addBlock();
7236		7244
7237	root->appendNew<ControlValue>(	7245	root->appendNewControlValue(
7238	proc, Branch, Origin(),	7246	proc, Branch, Origin(),
7239	root->appendNew<MemoryValue>(	7247	root->appendNew<MemoryValue>(
7240	proc, Load16S, Origin(),	7248	proc, Load16S, Origin(),
7241	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	7249	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
7242	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7250	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7243		7251
7244	thenCase->appendNew<ControlValue>(	7252	thenCase->appendNewControlValue(
7245	proc, Return, Origin(),	7253	proc, Return, Origin(),
7246	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7254	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7247		7255
7248	elseCase->appendNew<ControlValue>(	7256	elseCase->appendNewControlValue(
7249	proc, Return, Origin(),	7257	proc, Return, Origin(),
7250	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7258	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7251		7259
Lines 7264-7281 void testBranchLoad16Z() Source/JavaScriptCore/b3/testb3.cpp_sec417
7264	BasicBlock* thenCase = proc.addBlock();	7272	BasicBlock* thenCase = proc.addBlock();
7265	BasicBlock* elseCase = proc.addBlock();	7273	BasicBlock* elseCase = proc.addBlock();
7266		7274
7267	root->appendNew<ControlValue>(	7275	root->appendNewControlValue(
7268	proc, Branch, Origin(),	7276	proc, Branch, Origin(),
7269	root->appendNew<MemoryValue>(	7277	root->appendNew<MemoryValue>(
7270	proc, Load16Z, Origin(),	7278	proc, Load16Z, Origin(),
7271	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	7279	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
7272	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7280	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7273		7281
7274	thenCase->appendNew<ControlValue>(	7282	thenCase->appendNewControlValue(
7275	proc, Return, Origin(),	7283	proc, Return, Origin(),
7276	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7284	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7277		7285
7278	elseCase->appendNew<ControlValue>(	7286	elseCase->appendNewControlValue(
7279	proc, Return, Origin(),	7287	proc, Return, Origin(),
7280	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7288	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7281		7289
Lines 7295-7301 void testBranch8WithLoad8ZIndex() Source/JavaScriptCore/b3/testb3.cpp_sec418
7295	BasicBlock* elseCase = proc.addBlock();	7303	BasicBlock* elseCase = proc.addBlock();
7296		7304
7297	int logScale = 1;	7305	int logScale = 1;
7298	root->appendNew<ControlValue>(	7306	root->appendNewControlValue(
7299	proc, Branch, Origin(),	7307	proc, Branch, Origin(),
7300	root->appendNew<Value>(	7308	root->appendNew<Value>(
7301	proc, Above, Origin(),	7309	proc, Above, Origin(),
Lines 7311-7321 void testBranch8WithLoad8ZIndex() Source/JavaScriptCore/b3/testb3.cpp_sec419
7311	root->appendNew<Const32Value>(proc, Origin(), 250)),	7319	root->appendNew<Const32Value>(proc, Origin(), 250)),
7312	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	7320	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
7313		7321
7314	thenCase->appendNew<ControlValue>(	7322	thenCase->appendNewControlValue(
7315	proc, Return, Origin(),	7323	proc, Return, Origin(),
7316	thenCase->appendNew<Const32Value>(proc, Origin(), 1));	7324	thenCase->appendNew<Const32Value>(proc, Origin(), 1));
7317		7325
7318	elseCase->appendNew<ControlValue>(	7326	elseCase->appendNewControlValue(
7319	proc, Return, Origin(),	7327	proc, Return, Origin(),
7320	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	7328	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
7321		7329
Lines 7357-7363 void testComplex(unsigned numVars, unsig Source/JavaScriptCore/b3/testb3.cpp_sec420
7357	BasicBlock* elseBlock = proc.addBlock();	7365	BasicBlock* elseBlock = proc.addBlock();
7358	BasicBlock* continuation = proc.addBlock();	7366	BasicBlock* continuation = proc.addBlock();
7359		7367
7360	current->appendNew<ControlValue>(	7368	current->appendNewControlValue(
7361	proc, Branch, Origin(), vars[predicateVarIndex],	7369	proc, Branch, Origin(), vars[predicateVarIndex],
7362	FrequentedBlock(thenBlock), FrequentedBlock(elseBlock));	7370	FrequentedBlock(thenBlock), FrequentedBlock(elseBlock));
7363		7371
Lines 7366-7379 void testComplex(unsigned numVars, unsig Source/JavaScriptCore/b3/testb3.cpp_sec421
7366	thenBlock->appendNew<Value>(proc, Add, Origin(), vars[thenIncVarIndex], one));	7374	thenBlock->appendNew<Value>(proc, Add, Origin(), vars[thenIncVarIndex], one));
7367	UpsilonValue* thenElseResult = thenBlock->appendNew<UpsilonValue>(	7375	UpsilonValue* thenElseResult = thenBlock->appendNew<UpsilonValue>(
7368	proc, Origin(), vars[elseIncVarIndex]);	7376	proc, Origin(), vars[elseIncVarIndex]);
7369	thenBlock->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(continuation));	7377	thenBlock->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(continuation));
7370		7378
7371	UpsilonValue* elseElseResult = elseBlock->appendNew<UpsilonValue>(	7379	UpsilonValue* elseElseResult = elseBlock->appendNew<UpsilonValue>(
7372	proc, Origin(),	7380	proc, Origin(),
7373	elseBlock->appendNew<Value>(proc, Add, Origin(), vars[elseIncVarIndex], one));	7381	elseBlock->appendNew<Value>(proc, Add, Origin(), vars[elseIncVarIndex], one));
7374	UpsilonValue* elseThenResult = elseBlock->appendNew<UpsilonValue>(	7382	UpsilonValue* elseThenResult = elseBlock->appendNew<UpsilonValue>(
7375	proc, Origin(), vars[thenIncVarIndex]);	7383	proc, Origin(), vars[thenIncVarIndex]);
7376	elseBlock->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(continuation));	7384	elseBlock->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(continuation));
7377		7385
7378	Value* thenPhi = continuation->appendNew<Value>(proc, Phi, Int32, Origin());	7386	Value* thenPhi = continuation->appendNew<Value>(proc, Phi, Int32, Origin());
7379	thenThenResult->setPhi(thenPhi);	7387	thenThenResult->setPhi(thenPhi);
Lines 7398-7404 void testComplex(unsigned numVars, unsig Source/JavaScriptCore/b3/testb3.cpp_sec422
7398		7406
7399	Value* startIndex = vars[((i >> 1) + 1) % numVars];	7407	Value* startIndex = vars[((i >> 1) + 1) % numVars];
7400	Value* startSum = current->appendNew<Const32Value>(proc, Origin(), 0);	7408	Value* startSum = current->appendNew<Const32Value>(proc, Origin(), 0);
7401	current->appendNew<ControlValue>(	7409	current->appendNewControlValue(
7402	proc, Branch, Origin(), startIndex,	7410	proc, Branch, Origin(), startIndex,
7403	FrequentedBlock(loopEntry), FrequentedBlock(loopSkip));	7411	FrequentedBlock(loopEntry), FrequentedBlock(loopSkip));
7404		7412
Lines 7406-7412 void testComplex(unsigned numVars, unsig Source/JavaScriptCore/b3/testb3.cpp_sec423
7406	proc, Origin(), startIndex);	7414	proc, Origin(), startIndex);
7407	UpsilonValue* startSumForBody = loopEntry->appendNew<UpsilonValue>(	7415	UpsilonValue* startSumForBody = loopEntry->appendNew<UpsilonValue>(
7408	proc, Origin(), startSum);	7416	proc, Origin(), startSum);
7409	loopEntry->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(loopBody));	7417	loopEntry->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(loopBody));
7410		7418
7411	Value* bodyIndex = loopBody->appendNew<Value>(proc, Phi, Int32, Origin());	7419	Value* bodyIndex = loopBody->appendNew<Value>(proc, Phi, Int32, Origin());
7412	startIndexForBody->setPhi(bodyIndex);	7420	startIndexForBody->setPhi(bodyIndex);
Lines 7431-7449 void testComplex(unsigned numVars, unsig Source/JavaScriptCore/b3/testb3.cpp_sec424
7431	loopBody->appendNew<Const32Value>(	7439	loopBody->appendNew<Const32Value>(
7432	proc, Origin(), numVars - 1))),	7440	proc, Origin(), numVars - 1))),
7433	loopBody->appendNew<Const32Value>(proc, Origin(), 2)))));	7441	loopBody->appendNew<Const32Value>(proc, Origin(), 2)))));
7434	loopBody->appendNew<ControlValue>(	7442	loopBody->appendNewControlValue(
7435	proc, Branch, Origin(), newBodyIndex,	7443	proc, Branch, Origin(), newBodyIndex,
7436	FrequentedBlock(loopReentry), FrequentedBlock(loopExit));	7444	FrequentedBlock(loopReentry), FrequentedBlock(loopExit));
7437		7445
7438	loopReentry->appendNew<UpsilonValue>(proc, Origin(), newBodyIndex, bodyIndex);	7446	loopReentry->appendNew<UpsilonValue>(proc, Origin(), newBodyIndex, bodyIndex);
7439	loopReentry->appendNew<UpsilonValue>(proc, Origin(), newBodySum, bodySum);	7447	loopReentry->appendNew<UpsilonValue>(proc, Origin(), newBodySum, bodySum);
7440	loopReentry->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(loopBody));	7448	loopReentry->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(loopBody));
7441		7449
7442	UpsilonValue* exitSum = loopExit->appendNew<UpsilonValue>(proc, Origin(), newBodySum);	7450	UpsilonValue* exitSum = loopExit->appendNew<UpsilonValue>(proc, Origin(), newBodySum);
7443	loopExit->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(continuation));	7451	loopExit->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(continuation));
7444		7452
7445	UpsilonValue* skipSum = loopSkip->appendNew<UpsilonValue>(proc, Origin(), startSum);	7453	UpsilonValue* skipSum = loopSkip->appendNew<UpsilonValue>(proc, Origin(), startSum);
7446	loopSkip->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(continuation));	7454	loopSkip->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(continuation));
7447		7455
7448	Value* finalSum = continuation->appendNew<Value>(proc, Phi, Int32, Origin());	7456	Value* finalSum = continuation->appendNew<Value>(proc, Phi, Int32, Origin());
7449	exitSum->setPhi(finalSum);	7457	exitSum->setPhi(finalSum);
Lines 7454-7460 void testComplex(unsigned numVars, unsig Source/JavaScriptCore/b3/testb3.cpp_sec425
7454	}	7462	}
7455	}	7463	}
7456		7464
7457	current->appendNew<ControlValue>(proc, Return, Origin(), vars[0]);	7465	current->appendNewControlValue(proc, Return, Origin(), vars[0]);
7458		7466
7459	compile(proc);	7467	compile(proc);
7460		7468
Lines 7480-7486 void testSimplePatchpoint() Source/JavaScriptCore/b3/testb3.cpp_sec426
7480	CHECK(params[2].isGPR());	7488	CHECK(params[2].isGPR());
7481	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());	7489	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());
7482	});	7490	});
7483	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7491	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7484		7492
7485	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7493	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7486	}	7494	}
Lines 7511-7517 void testSimplePatchpointWithoutOuputClo Source/JavaScriptCore/b3/testb3.cpp_sec427
7511	});	7519	});
7512		7520
7513	Value* result = root->appendNew<Value>(proc, Add, Origin(), arg1, arg2);	7521	Value* result = root->appendNew<Value>(proc, Add, Origin(), arg1, arg2);
7514	root->appendNew<ControlValue>(proc, Return, Origin(), result);	7522	root->appendNewControlValue(proc, Return, Origin(), result);
7515		7523
7516	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7524	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7517	}	7525	}
Lines 7560-7566 void testSimplePatchpointWithOuputClobbe Source/JavaScriptCore/b3/testb3.cpp_sec428
7560		7568
7561	Value* result = root->appendNew<Value>(proc, Add, Origin(), patchpoint,	7569	Value* result = root->appendNew<Value>(proc, Add, Origin(), patchpoint,
7562	root->appendNew<Value>(proc, Add, Origin(), arg1, arg2));	7570	root->appendNew<Value>(proc, Add, Origin(), arg1, arg2));
7563	root->appendNew<ControlValue>(proc, Return, Origin(), result);	7571	root->appendNewControlValue(proc, Return, Origin(), result);
7564		7572
7565	CHECK(compileAndRun<int>(proc, 1, 2) == 58);	7573	CHECK(compileAndRun<int>(proc, 1, 2) == 58);
7566	}	7574	}
Lines 7591-7597 void testSimplePatchpointWithoutOuputClo Source/JavaScriptCore/b3/testb3.cpp_sec429
7591	});	7599	});
7592		7600
7593	Value* result = root->appendNew<Value>(proc, Add, Origin(), arg1, arg2);	7601	Value* result = root->appendNew<Value>(proc, Add, Origin(), arg1, arg2);
7594	root->appendNew<ControlValue>(proc, Return, Origin(), result);	7602	root->appendNewControlValue(proc, Return, Origin(), result);
7595		7603
7596	CHECK(compileAndRun<double>(proc, 1.5, 2.5) == 4);	7604	CHECK(compileAndRun<double>(proc, 1.5, 2.5) == 4);
7597	}	7605	}
Lines 7632-7638 void testSimplePatchpointWithOuputClobbe Source/JavaScriptCore/b3/testb3.cpp_sec430
7632		7640
7633	Value* result = root->appendNew<Value>(proc, Add, Origin(), patchpoint,	7641	Value* result = root->appendNew<Value>(proc, Add, Origin(), patchpoint,
7634	root->appendNew<Value>(proc, Add, Origin(), arg1, arg2));	7642	root->appendNew<Value>(proc, Add, Origin(), arg1, arg2));
7635	root->appendNew<ControlValue>(proc, Return, Origin(), result);	7643	root->appendNewControlValue(proc, Return, Origin(), result);
7636		7644
7637	CHECK(compileAndRun<double>(proc, 1.5, 2.5) == 59.6);	7645	CHECK(compileAndRun<double>(proc, 1.5, 2.5) == 59.6);
7638	}	7646	}
Lines 7657-7663 void testPatchpointWithEarlyClobber() Source/JavaScriptCore/b3/testb3.cpp_sec431
7657	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());	7665	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());
7658	});	7666	});
7659		7667
7660	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7668	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7661		7669
7662	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7670	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7663	};	7671	};
Lines 7690-7696 void testPatchpointCallArg() Source/JavaScriptCore/b3/testb3.cpp_sec432
7690	CCallHelpers::Address(GPRInfo::callFrameRegister, params[2].offsetFromFP()),	7698	CCallHelpers::Address(GPRInfo::callFrameRegister, params[2].offsetFromFP()),
7691	params[0].gpr());	7699	params[0].gpr());
7692	});	7700	});
7693	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7701	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7694		7702
7695	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7703	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7696	}	7704	}
Lines 7713-7719 void testPatchpointFixedRegister() Source/JavaScriptCore/b3/testb3.cpp_sec433
7713	CHECK(params[2] == ValueRep(GPRInfo::regT1));	7721	CHECK(params[2] == ValueRep(GPRInfo::regT1));
7714	add32(jit, GPRInfo::regT0, GPRInfo::regT1, params[0].gpr());	7722	add32(jit, GPRInfo::regT0, GPRInfo::regT1, params[0].gpr());
7715	});	7723	});
7716	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7724	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7717		7725
7718	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7726	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7719	}	7727	}
Lines 7737-7743 void testPatchpointAny(ValueRep rep) Source/JavaScriptCore/b3/testb3.cpp_sec434
7737	CHECK(params[2].isGPR());	7745	CHECK(params[2].isGPR());
7738	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());	7746	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());
7739	});	7747	});
7740	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7748	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7741		7749
7742	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7750	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7743	}	7751	}
Lines 7773-7779 void testPatchpointGPScratch() Source/JavaScriptCore/b3/testb3.cpp_sec435
7773	CHECK(!params.unavailableRegisters().get(params.gpScratch(1)));	7781	CHECK(!params.unavailableRegisters().get(params.gpScratch(1)));
7774	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());	7782	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());
7775	});	7783	});
7776	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7784	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7777		7785
7778	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7786	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7779	}	7787	}
Lines 7803-7809 void testPatchpointFPScratch() Source/JavaScriptCore/b3/testb3.cpp_sec436
7803	CHECK(!params.unavailableRegisters().get(params.fpScratch(1)));	7811	CHECK(!params.unavailableRegisters().get(params.fpScratch(1)));
7804	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());	7812	add32(jit, params[1].gpr(), params[2].gpr(), params[0].gpr());
7805	});	7813	});
7806	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7814	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7807		7815
7808	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7816	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7809	}	7817	}
Lines 7845-7851 void testPatchpointLotsOfLateAnys() Source/JavaScriptCore/b3/testb3.cpp_sec437
7845	}	7853	}
7846	}	7854	}
7847	});	7855	});
7848	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7856	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7849		7857
7850	CHECK(compileAndRun<int>(proc) == (things.size() * (things.size() - 1)) / 2);	7858	CHECK(compileAndRun<int>(proc) == (things.size() * (things.size() - 1)) / 2);
7851	}	7859	}
Lines 7873-7879 void testPatchpointAnyImm(ValueRep rep) Source/JavaScriptCore/b3/testb3.cpp_sec438
7873	CCallHelpers::TrustedImm32(static_cast<int32_t>(params[2].value())),	7881	CCallHelpers::TrustedImm32(static_cast<int32_t>(params[2].value())),
7874	params[1].gpr(), params[0].gpr());	7882	params[1].gpr(), params[0].gpr());
7875	});	7883	});
7876	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7884	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7877		7885
7878	CHECK(compileAndRun<int>(proc, 1) == 43);	7886	CHECK(compileAndRun<int>(proc, 1) == 43);
7879	}	7887	}
Lines 7899-7905 void testPatchpointManyImms() Source/JavaScriptCore/b3/testb3.cpp_sec439
7899	CHECK(params[2] == ValueRep::constant(43000000000000ll));	7907	CHECK(params[2] == ValueRep::constant(43000000000000ll));
7900	CHECK(params[3] == ValueRep::constant(bitwise_cast<int64_t>(42.5)));	7908	CHECK(params[3] == ValueRep::constant(bitwise_cast<int64_t>(42.5)));
7901	});	7909	});
7902	root->appendNew<ControlValue>(	7910	root->appendNewControlValue(
7903	proc, Return, Origin(),	7911	proc, Return, Origin(),
7904	root->appendNew<Const32Value>(proc, Origin(), 0));	7912	root->appendNew<Const32Value>(proc, Origin(), 0));
7905		7913
Lines 7925-7931 void testPatchpointWithRegisterResult() Source/JavaScriptCore/b3/testb3.cpp_sec440
7925	CHECK(params[2].isGPR());	7933	CHECK(params[2].isGPR());
7926	add32(jit, params[1].gpr(), params[2].gpr(), GPRInfo::nonArgGPR0);	7934	add32(jit, params[1].gpr(), params[2].gpr(), GPRInfo::nonArgGPR0);
7927	});	7935	});
7928	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7936	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7929		7937
7930	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7938	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7931	}	7939	}
Lines 7951-7957 void testPatchpointWithStackArgumentResu Source/JavaScriptCore/b3/testb3.cpp_sec441
7951	jit.add32(params[1].gpr(), params[2].gpr(), jit.scratchRegister());	7959	jit.add32(params[1].gpr(), params[2].gpr(), jit.scratchRegister());
7952	jit.store32(jit.scratchRegister(), CCallHelpers::Address(CCallHelpers::stackPointerRegister, 0));	7960	jit.store32(jit.scratchRegister(), CCallHelpers::Address(CCallHelpers::stackPointerRegister, 0));
7953	});	7961	});
7954	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7962	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7955		7963
7956	CHECK(compileAndRun<int>(proc, 1, 2) == 3);	7964	CHECK(compileAndRun<int>(proc, 1, 2) == 3);
7957	}	7965	}
Lines 7980-7986 void testPatchpointWithAnyResult() Source/JavaScriptCore/b3/testb3.cpp_sec442
7980	jit.convertInt32ToDouble(GPRInfo::regT0, FPRInfo::fpRegT0);	7988	jit.convertInt32ToDouble(GPRInfo::regT0, FPRInfo::fpRegT0);
7981	jit.storeDouble(FPRInfo::fpRegT0, CCallHelpers::Address(GPRInfo::callFrameRegister, params[0].offsetFromFP()));	7989	jit.storeDouble(FPRInfo::fpRegT0, CCallHelpers::Address(GPRInfo::callFrameRegister, params[0].offsetFromFP()));
7982	});	7990	});
7983	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	7991	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
7984		7992
7985	CHECK(compileAndRun<double>(proc, 1, 2) == 3);	7993	CHECK(compileAndRun<double>(proc, 1, 2) == 3);
7986	}	7994	}
Lines 8002-8008 void testSimpleCheck() Source/JavaScriptCore/b3/testb3.cpp_sec443
8002	jit.emitFunctionEpilogue();	8010	jit.emitFunctionEpilogue();
8003	jit.ret();	8011	jit.ret();
8004	});	8012	});
8005	root->appendNew<ControlValue>(	8013	root->appendNewControlValue(
8006	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	8014	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
8007		8015
8008	auto code = compile(proc);	8016	auto code = compile(proc);
Lines 8021-8027 void testCheckFalse() Source/JavaScriptCore/b3/testb3.cpp_sec444
8021	[&] (CCallHelpers&, const StackmapGenerationParams&) {	8029	[&] (CCallHelpers&, const StackmapGenerationParams&) {
8022	CHECK(!"This should not have executed");	8030	CHECK(!"This should not have executed");
8023	});	8031	});
8024	root->appendNew<ControlValue>(	8032	root->appendNewControlValue(
8025	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	8033	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
8026		8034
8027	auto code = compile(proc);	8035	auto code = compile(proc);
Lines 8047-8053 void testCheckTrue() Source/JavaScriptCore/b3/testb3.cpp_sec445
8047	jit.emitFunctionEpilogue();	8055	jit.emitFunctionEpilogue();
8048	jit.ret();	8056	jit.ret();
8049	});	8057	});
8050	root->appendNew<ControlValue>(	8058	root->appendNewControlValue(
8051	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	8059	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
8052		8060
8053	auto code = compile(proc);	8061	auto code = compile(proc);
Lines 8078-8084 void testCheckLessThan() Source/JavaScriptCore/b3/testb3.cpp_sec446
8078	jit.emitFunctionEpilogue();	8086	jit.emitFunctionEpilogue();
8079	jit.ret();	8087	jit.ret();
8080	});	8088	});
8081	root->appendNew<ControlValue>(	8089	root->appendNewControlValue(
8082	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	8090	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
8083		8091
8084	auto code = compile(proc);	8092	auto code = compile(proc);
Lines 8124-8130 void testCheckMegaCombo() Source/JavaScriptCore/b3/testb3.cpp_sec447
8124	jit.emitFunctionEpilogue();	8132	jit.emitFunctionEpilogue();
8125	jit.ret();	8133	jit.ret();
8126	});	8134	});
8127	root->appendNew<ControlValue>(	8135	root->appendNewControlValue(
8128	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	8136	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
8129		8137
8130	auto code = compile(proc);	8138	auto code = compile(proc);
Lines 8179-8185 void testCheckTrickyMegaCombo() Source/JavaScriptCore/b3/testb3.cpp_sec448
8179	jit.emitFunctionEpilogue();	8187	jit.emitFunctionEpilogue();
8180	jit.ret();	8188	jit.ret();
8181	});	8189	});
8182	root->appendNew<ControlValue>(	8190	root->appendNewControlValue(
8183	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	8191	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
8184		8192
8185	auto code = compile(proc);	8193	auto code = compile(proc);
Lines 8243-8249 void testCheckTwoMegaCombos() Source/JavaScriptCore/b3/testb3.cpp_sec449
8243	jit.emitFunctionEpilogue();	8251	jit.emitFunctionEpilogue();
8244	jit.ret();	8252	jit.ret();
8245	});	8253	});
8246	root->appendNew<ControlValue>(	8254	root->appendNewControlValue(
8247	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));	8255	proc, Return, Origin(), root->appendNew<Const32Value>(proc, Origin(), 0));
8248		8256
8249	auto code = compile(proc);	8257	auto code = compile(proc);
Lines 8293-8299 void testCheckTwoNonRedundantMegaCombos( Source/JavaScriptCore/b3/testb3.cpp_sec450
8293	root->appendNew<MemoryValue>(proc, Load8S, Origin(), ptr),	8301	root->appendNew<MemoryValue>(proc, Load8S, Origin(), ptr),
8294	root->appendNew<Const32Value>(proc, Origin(), 42));	8302	root->appendNew<Const32Value>(proc, Origin(), 42));
8295		8303
8296	root->appendNew<ControlValue>(	8304	root->appendNewControlValue(
8297	proc, Branch, Origin(), branchPredicate,	8305	proc, Branch, Origin(), branchPredicate,
8298	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	8306	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
8299		8307
Lines 8309-8315 void testCheckTwoNonRedundantMegaCombos( Source/JavaScriptCore/b3/testb3.cpp_sec451
8309	jit.emitFunctionEpilogue();	8317	jit.emitFunctionEpilogue();
8310	jit.ret();	8318	jit.ret();
8311	});	8319	});
8312	thenCase->appendNew<ControlValue>(	8320	thenCase->appendNewControlValue(
8313	proc, Return, Origin(), thenCase->appendNew<Const32Value>(proc, Origin(), 43));	8321	proc, Return, Origin(), thenCase->appendNew<Const32Value>(proc, Origin(), 43));
8314		8322
8315	CheckValue* check2 = elseCase->appendNew<CheckValue>(proc, Check, Origin(), checkPredicate);	8323	CheckValue* check2 = elseCase->appendNew<CheckValue>(proc, Check, Origin(), checkPredicate);
Lines 8324-8330 void testCheckTwoNonRedundantMegaCombos( Source/JavaScriptCore/b3/testb3.cpp_sec452
8324	jit.emitFunctionEpilogue();	8332	jit.emitFunctionEpilogue();
8325	jit.ret();	8333	jit.ret();
8326	});	8334	});
8327	elseCase->appendNew<ControlValue>(	8335	elseCase->appendNewControlValue(
8328	proc, Return, Origin(), elseCase->appendNew<Const32Value>(proc, Origin(), 45));	8336	proc, Return, Origin(), elseCase->appendNew<Const32Value>(proc, Origin(), 45));
8329		8337
8330	auto code = compile(proc);	8338	auto code = compile(proc);
Lines 8378-8384 void testCheckAddImm() Source/JavaScriptCore/b3/testb3.cpp_sec453
8378	jit.emitFunctionEpilogue();	8386	jit.emitFunctionEpilogue();
8379	jit.ret();	8387	jit.ret();
8380	});	8388	});
8381	root->appendNew<ControlValue>(	8389	root->appendNewControlValue(
8382	proc, Return, Origin(),	8390	proc, Return, Origin(),
8383	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));	8391	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
8384		8392
Lines 8414-8420 void testCheckAddImmCommute() Source/JavaScriptCore/b3/testb3.cpp_sec454
8414	jit.emitFunctionEpilogue();	8422	jit.emitFunctionEpilogue();
8415	jit.ret();	8423	jit.ret();
8416	});	8424	});
8417	root->appendNew<ControlValue>(	8425	root->appendNewControlValue(
8418	proc, Return, Origin(),	8426	proc, Return, Origin(),
8419	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));	8427	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
8420		8428
Lines 8449-8455 void testCheckAddImmSomeRegister() Source/JavaScriptCore/b3/testb3.cpp_sec455
8449	jit.emitFunctionEpilogue();	8457	jit.emitFunctionEpilogue();
8450	jit.ret();	8458	jit.ret();
8451	});	8459	});
8452	root->appendNew<ControlValue>(	8460	root->appendNewControlValue(
8453	proc, Return, Origin(),	8461	proc, Return, Origin(),
8454	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));	8462	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
8455		8463
Lines 8486-8492 void testCheckAdd() Source/JavaScriptCore/b3/testb3.cpp_sec456
8486	jit.emitFunctionEpilogue();	8494	jit.emitFunctionEpilogue();
8487	jit.ret();	8495	jit.ret();
8488	});	8496	});
8489	root->appendNew<ControlValue>(	8497	root->appendNewControlValue(
8490	proc, Return, Origin(),	8498	proc, Return, Origin(),
8491	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));	8499	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
8492		8500
Lines 8519-8525 void testCheckAdd64() Source/JavaScriptCore/b3/testb3.cpp_sec457
8519	jit.emitFunctionEpilogue();	8527	jit.emitFunctionEpilogue();
8520	jit.ret();	8528	jit.ret();
8521	});	8529	});
8522	root->appendNew<ControlValue>(	8530	root->appendNewControlValue(
8523	proc, Return, Origin(),	8531	proc, Return, Origin(),
8524	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));	8532	root->appendNew<Value>(proc, IToD, Origin(), checkAdd));
8525		8533
Lines 8542-8548 void testCheckAddFold(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec458
8542	[&] (CCallHelpers&, const StackmapGenerationParams&) {	8550	[&] (CCallHelpers&, const StackmapGenerationParams&) {
8543	CHECK(!"Should have been folded");	8551	CHECK(!"Should have been folded");
8544	});	8552	});
8545	root->appendNew<ControlValue>(proc, Return, Origin(), checkAdd);	8553	root->appendNewControlValue(proc, Return, Origin(), checkAdd);
8546		8554
8547	auto code = compile(proc);	8555	auto code = compile(proc);
8548		8556
Lines 8563-8569 void testCheckAddFoldFail(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec459
8563	jit.emitFunctionEpilogue();	8571	jit.emitFunctionEpilogue();
8564	jit.ret();	8572	jit.ret();
8565	});	8573	});
8566	root->appendNew<ControlValue>(proc, Return, Origin(), checkAdd);	8574	root->appendNewControlValue(proc, Return, Origin(), checkAdd);
8567		8575
8568	auto code = compile(proc);	8576	auto code = compile(proc);
8569		8577
Lines 8602-8608 void testCheckAddArgumentAliasing64() Source/JavaScriptCore/b3/testb3.cpp_sec460
8602	CheckValue* checkAdd3 = root->appendNew<CheckValue>(proc, CheckAdd, Origin(), checkAdd1, checkAdd2);	8610	CheckValue* checkAdd3 = root->appendNew<CheckValue>(proc, CheckAdd, Origin(), checkAdd1, checkAdd2);
8603	checkAdd3->setGenerator([&] (CCallHelpers& jit, const StackmapGenerationParams&) { jit.oops(); });	8611	checkAdd3->setGenerator([&] (CCallHelpers& jit, const StackmapGenerationParams&) { jit.oops(); });
8604		8612
8605	root->appendNew<ControlValue>(proc, Return, Origin(), checkAdd3);	8613	root->appendNewControlValue(proc, Return, Origin(), checkAdd3);
8606		8614
8607	CHECK(compileAndRun<int64_t>(proc, 1, 2, 3) == 8);	8615	CHECK(compileAndRun<int64_t>(proc, 1, 2, 3) == 8);
8608	}	8616	}
Lines 8645-8651 void testCheckAddArgumentAliasing32() Source/JavaScriptCore/b3/testb3.cpp_sec461
8645	CheckValue* checkAdd3 = root->appendNew<CheckValue>(proc, CheckAdd, Origin(), checkAdd1, checkAdd2);	8653	CheckValue* checkAdd3 = root->appendNew<CheckValue>(proc, CheckAdd, Origin(), checkAdd1, checkAdd2);
8646	checkAdd3->setGenerator([&] (CCallHelpers& jit, const StackmapGenerationParams&) { jit.oops(); });	8654	checkAdd3->setGenerator([&] (CCallHelpers& jit, const StackmapGenerationParams&) { jit.oops(); });
8647		8655
8648	root->appendNew<ControlValue>(proc, Return, Origin(), checkAdd3);	8656	root->appendNewControlValue(proc, Return, Origin(), checkAdd3);
8649		8657
8650	CHECK(compileAndRun<int32_t>(proc, 1, 2, 3) == 8);	8658	CHECK(compileAndRun<int32_t>(proc, 1, 2, 3) == 8);
8651	}	8659	}
Lines 8670-8676 void testCheckAddSelfOverflow64() Source/JavaScriptCore/b3/testb3.cpp_sec462
8670	opaqueUse->append(ConstrainedValue(arg, ValueRep::SomeRegister));	8678	opaqueUse->append(ConstrainedValue(arg, ValueRep::SomeRegister));
8671	opaqueUse->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	8679	opaqueUse->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
8672		8680
8673	root->appendNew<ControlValue>(proc, Return, Origin(), checkAdd);	8681	root->appendNewControlValue(proc, Return, Origin(), checkAdd);
8674		8682
8675	auto code = compile(proc);	8683	auto code = compile(proc);
8676		8684
Lines 8701-8707 void testCheckAddSelfOverflow32() Source/JavaScriptCore/b3/testb3.cpp_sec463
8701	opaqueUse->append(ConstrainedValue(arg, ValueRep::SomeRegister));	8709	opaqueUse->append(ConstrainedValue(arg, ValueRep::SomeRegister));
8702	opaqueUse->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	8710	opaqueUse->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
8703		8711
8704	root->appendNew<ControlValue>(proc, Return, Origin(), checkAdd);	8712	root->appendNewControlValue(proc, Return, Origin(), checkAdd);
8705		8713
8706	auto code = compile(proc);	8714	auto code = compile(proc);
8707		8715
Lines 8734-8740 void testCheckSubImm() Source/JavaScriptCore/b3/testb3.cpp_sec464
8734	jit.emitFunctionEpilogue();	8742	jit.emitFunctionEpilogue();
8735	jit.ret();	8743	jit.ret();
8736	});	8744	});
8737	root->appendNew<ControlValue>(	8745	root->appendNewControlValue(
8738	proc, Return, Origin(),	8746	proc, Return, Origin(),
8739	root->appendNew<Value>(proc, IToD, Origin(), checkSub));	8747	root->appendNew<Value>(proc, IToD, Origin(), checkSub));
8740		8748
Lines 8776-8782 void testCheckSubBadImm() Source/JavaScriptCore/b3/testb3.cpp_sec465
8776	jit.emitFunctionEpilogue();	8784	jit.emitFunctionEpilogue();
8777	jit.ret();	8785	jit.ret();
8778	});	8786	});
8779	root->appendNew<ControlValue>(	8787	root->appendNewControlValue(
8780	proc, Return, Origin(),	8788	proc, Return, Origin(),
8781	root->appendNew<Value>(proc, IToD, Origin(), checkSub));	8789	root->appendNew<Value>(proc, IToD, Origin(), checkSub));
8782		8790
Lines 8813-8819 void testCheckSub() Source/JavaScriptCore/b3/testb3.cpp_sec466
8813	jit.emitFunctionEpilogue();	8821	jit.emitFunctionEpilogue();
8814	jit.ret();	8822	jit.ret();
8815	});	8823	});
8816	root->appendNew<ControlValue>(	8824	root->appendNewControlValue(
8817	proc, Return, Origin(),	8825	proc, Return, Origin(),
8818	root->appendNew<Value>(proc, IToD, Origin(), checkSub));	8826	root->appendNew<Value>(proc, IToD, Origin(), checkSub));
8819		8827
Lines 8851-8857 void testCheckSub64() Source/JavaScriptCore/b3/testb3.cpp_sec467
8851	jit.emitFunctionEpilogue();	8859	jit.emitFunctionEpilogue();
8852	jit.ret();	8860	jit.ret();
8853	});	8861	});
8854	root->appendNew<ControlValue>(	8862	root->appendNewControlValue(
8855	proc, Return, Origin(),	8863	proc, Return, Origin(),
8856	root->appendNew<Value>(proc, IToD, Origin(), checkSub));	8864	root->appendNew<Value>(proc, IToD, Origin(), checkSub));
8857		8865
Lines 8874-8880 void testCheckSubFold(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec468
8874	[&] (CCallHelpers&, const StackmapGenerationParams&) {	8882	[&] (CCallHelpers&, const StackmapGenerationParams&) {
8875	CHECK(!"Should have been folded");	8883	CHECK(!"Should have been folded");
8876	});	8884	});
8877	root->appendNew<ControlValue>(proc, Return, Origin(), checkSub);	8885	root->appendNewControlValue(proc, Return, Origin(), checkSub);
8878		8886
8879	auto code = compile(proc);	8887	auto code = compile(proc);
8880		8888
Lines 8895-8901 void testCheckSubFoldFail(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec469
8895	jit.emitFunctionEpilogue();	8903	jit.emitFunctionEpilogue();
8896	jit.ret();	8904	jit.ret();
8897	});	8905	});
8898	root->appendNew<ControlValue>(proc, Return, Origin(), checkSub);	8906	root->appendNewControlValue(proc, Return, Origin(), checkSub);
8899		8907
8900	auto code = compile(proc);	8908	auto code = compile(proc);
8901		8909
Lines 8922-8928 void testCheckNeg() Source/JavaScriptCore/b3/testb3.cpp_sec470
8922	jit.emitFunctionEpilogue();	8930	jit.emitFunctionEpilogue();
8923	jit.ret();	8931	jit.ret();
8924	});	8932	});
8925	root->appendNew<ControlValue>(	8933	root->appendNewControlValue(
8926	proc, Return, Origin(),	8934	proc, Return, Origin(),
8927	root->appendNew<Value>(proc, IToD, Origin(), checkNeg));	8935	root->appendNew<Value>(proc, IToD, Origin(), checkNeg));
8928		8936
Lines 8952-8958 void testCheckNeg64() Source/JavaScriptCore/b3/testb3.cpp_sec471
8952	jit.emitFunctionEpilogue();	8960	jit.emitFunctionEpilogue();
8953	jit.ret();	8961	jit.ret();
8954	});	8962	});
8955	root->appendNew<ControlValue>(	8963	root->appendNewControlValue(
8956	proc, Return, Origin(),	8964	proc, Return, Origin(),
8957	root->appendNew<Value>(proc, IToD, Origin(), checkNeg));	8965	root->appendNew<Value>(proc, IToD, Origin(), checkNeg));
8958		8966
Lines 8989-8995 void testCheckMul() Source/JavaScriptCore/b3/testb3.cpp_sec472
8989	jit.emitFunctionEpilogue();	8997	jit.emitFunctionEpilogue();
8990	jit.ret();	8998	jit.ret();
8991	});	8999	});
8992	root->appendNew<ControlValue>(	9000	root->appendNewControlValue(
8993	proc, Return, Origin(),	9001	proc, Return, Origin(),
8994	root->appendNew<Value>(proc, IToD, Origin(), checkMul));	9002	root->appendNew<Value>(proc, IToD, Origin(), checkMul));
8995		9003
Lines 9030-9036 void testCheckMulMemory() Source/JavaScriptCore/b3/testb3.cpp_sec473
9030	jit.emitFunctionEpilogue();	9038	jit.emitFunctionEpilogue();
9031	jit.ret();	9039	jit.ret();
9032	});	9040	});
9033	root->appendNew<ControlValue>(	9041	root->appendNewControlValue(
9034	proc, Return, Origin(),	9042	proc, Return, Origin(),
9035	root->appendNew<Value>(proc, IToD, Origin(), checkMul));	9043	root->appendNew<Value>(proc, IToD, Origin(), checkMul));
9036		9044
Lines 9077-9083 void testCheckMul2() Source/JavaScriptCore/b3/testb3.cpp_sec474
9077	jit.emitFunctionEpilogue();	9085	jit.emitFunctionEpilogue();
9078	jit.ret();	9086	jit.ret();
9079	});	9087	});
9080	root->appendNew<ControlValue>(	9088	root->appendNewControlValue(
9081	proc, Return, Origin(),	9089	proc, Return, Origin(),
9082	root->appendNew<Value>(proc, IToD, Origin(), checkMul));	9090	root->appendNew<Value>(proc, IToD, Origin(), checkMul));
9083		9091
Lines 9110-9116 void testCheckMul64() Source/JavaScriptCore/b3/testb3.cpp_sec475
9110	jit.emitFunctionEpilogue();	9118	jit.emitFunctionEpilogue();
9111	jit.ret();	9119	jit.ret();
9112	});	9120	});
9113	root->appendNew<ControlValue>(	9121	root->appendNewControlValue(
9114	proc, Return, Origin(),	9122	proc, Return, Origin(),
9115	root->appendNew<Value>(proc, IToD, Origin(), checkMul));	9123	root->appendNew<Value>(proc, IToD, Origin(), checkMul));
9116		9124
Lines 9133-9139 void testCheckMulFold(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec476
9133	[&] (CCallHelpers&, const StackmapGenerationParams&) {	9141	[&] (CCallHelpers&, const StackmapGenerationParams&) {
9134	CHECK(!"Should have been folded");	9142	CHECK(!"Should have been folded");
9135	});	9143	});
9136	root->appendNew<ControlValue>(proc, Return, Origin(), checkMul);	9144	root->appendNewControlValue(proc, Return, Origin(), checkMul);
9137		9145
9138	auto code = compile(proc);	9146	auto code = compile(proc);
9139		9147
Lines 9154-9160 void testCheckMulFoldFail(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec477
9154	jit.emitFunctionEpilogue();	9162	jit.emitFunctionEpilogue();
9155	jit.ret();	9163	jit.ret();
9156	});	9164	});
9157	root->appendNew<ControlValue>(proc, Return, Origin(), checkMul);	9165	root->appendNewControlValue(proc, Return, Origin(), checkMul);
9158		9166
9159	auto code = compile(proc);	9167	auto code = compile(proc);
9160		9168
Lines 9193-9199 void testCheckMulArgumentAliasing64() Source/JavaScriptCore/b3/testb3.cpp_sec478
9193	CheckValue* checkMul3 = root->appendNew<CheckValue>(proc, CheckMul, Origin(), checkMul1, checkMul2);	9201	CheckValue* checkMul3 = root->appendNew<CheckValue>(proc, CheckMul, Origin(), checkMul1, checkMul2);
9194	checkMul3->setGenerator([&] (CCallHelpers& jit, const StackmapGenerationParams&) { jit.oops(); });	9202	checkMul3->setGenerator([&] (CCallHelpers& jit, const StackmapGenerationParams&) { jit.oops(); });
9195		9203
9196	root->appendNew<ControlValue>(proc, Return, Origin(), checkMul3);	9204	root->appendNewControlValue(proc, Return, Origin(), checkMul3);
9197		9205
9198	CHECK(compileAndRun<int64_t>(proc, 2, 3, 4) == 72);	9206	CHECK(compileAndRun<int64_t>(proc, 2, 3, 4) == 72);
9199	}	9207	}
Lines 9236-9242 void testCheckMulArgumentAliasing32() Source/JavaScriptCore/b3/testb3.cpp_sec479
9236	CheckValue* checkMul3 = root->appendNew<CheckValue>(proc, CheckMul, Origin(), checkMul1, checkMul2);	9244	CheckValue* checkMul3 = root->appendNew<CheckValue>(proc, CheckMul, Origin(), checkMul1, checkMul2);
9237	checkMul3->setGenerator([&] (CCallHelpers& jit, const StackmapGenerationParams&) { jit.oops(); });	9245	checkMul3->setGenerator([&] (CCallHelpers& jit, const StackmapGenerationParams&) { jit.oops(); });
9238		9246
9239	root->appendNew<ControlValue>(proc, Return, Origin(), checkMul3);	9247	root->appendNewControlValue(proc, Return, Origin(), checkMul3);
9240		9248
9241	CHECK(compileAndRun<int32_t>(proc, 2, 3, 4) == 72);	9249	CHECK(compileAndRun<int32_t>(proc, 2, 3, 4) == 72);
9242	}	9250	}
Lines 9268-9274 void testCheckMul64SShr() Source/JavaScriptCore/b3/testb3.cpp_sec480
9268	jit.emitFunctionEpilogue();	9276	jit.emitFunctionEpilogue();
9269	jit.ret();	9277	jit.ret();
9270	});	9278	});
9271	root->appendNew<ControlValue>(	9279	root->appendNewControlValue(
9272	proc, Return, Origin(),	9280	proc, Return, Origin(),
9273	root->appendNew<Value>(proc, IToD, Origin(), checkMul));	9281	root->appendNew<Value>(proc, IToD, Origin(), checkMul));
9274		9282
Lines 9294-9300 void genericTestCompare( Source/JavaScriptCore/b3/testb3.cpp_sec481
9294	Value* rightValue = rightFunctor(root, proc);	9302	Value* rightValue = rightFunctor(root, proc);
9295	Value* comparisonResult = root->appendNew<Value>(proc, opcode, Origin(), leftValue, rightValue);	9303	Value* comparisonResult = root->appendNew<Value>(proc, opcode, Origin(), leftValue, rightValue);
9296		9304
9297	root->appendNew<ControlValue>(	9305	root->appendNewControlValue(
9298	proc, Return, Origin(),	9306	proc, Return, Origin(),
9299	root->appendNew<Value>(	9307	root->appendNew<Value>(
9300	proc, NotEqual, Origin(),	9308	proc, NotEqual, Origin(),
Lines 9314-9320 void genericTestCompare( Source/JavaScriptCore/b3/testb3.cpp_sec482
9314	Value* leftValue = leftFunctor(root, proc);	9322	Value* leftValue = leftFunctor(root, proc);
9315	Value* rightValue = rightFunctor(root, proc);	9323	Value* rightValue = rightFunctor(root, proc);
9316		9324
9317	root->appendNew<ControlValue>(	9325	root->appendNewControlValue(
9318	proc, Branch, Origin(),	9326	proc, Branch, Origin(),
9319	root->appendNew<Value>(proc, opcode, Origin(), leftValue, rightValue),	9327	root->appendNew<Value>(proc, opcode, Origin(), leftValue, rightValue),
9320	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	9328	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
Lines 9328-9336 void genericTestCompare( Source/JavaScriptCore/b3/testb3.cpp_sec483
9328	CHECK(params[0].isGPR());	9336	CHECK(params[0].isGPR());
9329	jit.move(CCallHelpers::TrustedImm32(1), params[0].gpr());	9337	jit.move(CCallHelpers::TrustedImm32(1), params[0].gpr());
9330	});	9338	});
9331	thenCase->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	9339	thenCase->appendNewControlValue(proc, Return, Origin(), patchpoint);
9332		9340
9333	elseCase->appendNew<ControlValue>(	9341	elseCase->appendNewControlValue(
9334	proc, Return, Origin(),	9342	proc, Return, Origin(),
9335	elseCase->appendNew<Const32Value>(proc, Origin(), 0));	9343	elseCase->appendNew<Const32Value>(proc, Origin(), 0));
9336		9344
Lines 9569-9575 void testEqualDouble(double left, double Source/JavaScriptCore/b3/testb3.cpp_sec484
9569	{	9577	{
9570	Procedure proc;	9578	Procedure proc;
9571	BasicBlock* root = proc.addBlock();	9579	BasicBlock* root = proc.addBlock();
9572	root->appendNew<ControlValue>(	9580	root->appendNewControlValue(
9573	proc, Return, Origin(),	9581	proc, Return, Origin(),
9574	root->appendNew<Value>(	9582	root->appendNew<Value>(
9575	proc, Equal, Origin(),	9583	proc, Equal, Origin(),
Lines 9588-9594 void testCallSimple(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec485
9588	{	9596	{
9589	Procedure proc;	9597	Procedure proc;
9590	BasicBlock* root = proc.addBlock();	9598	BasicBlock* root = proc.addBlock();
9591	root->appendNew<ControlValue>(	9599	root->appendNewControlValue(
9592	proc, Return, Origin(),	9600	proc, Return, Origin(),
9593	root->appendNew<CCallValue>(	9601	root->appendNew<CCallValue>(
9594	proc, Int32, Origin(),	9602	proc, Int32, Origin(),
Lines 9606-9621 void testCallRare(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec486
9606	BasicBlock* common = proc.addBlock();	9614	BasicBlock* common = proc.addBlock();
9607	BasicBlock* rare = proc.addBlock();	9615	BasicBlock* rare = proc.addBlock();
9608		9616
9609	root->appendNew<ControlValue>(	9617	root->appendNewControlValue(
9610	proc, Branch, Origin(),	9618	proc, Branch, Origin(),
9611	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	9619	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
9612	FrequentedBlock(rare, FrequencyClass::Rare),	9620	FrequentedBlock(rare, FrequencyClass::Rare),
9613	FrequentedBlock(common));	9621	FrequentedBlock(common));
9614		9622
9615	common->appendNew<ControlValue>(	9623	common->appendNewControlValue(
9616	proc, Return, Origin(), common->appendNew<Const32Value>(proc, Origin(), 0));	9624	proc, Return, Origin(), common->appendNew<Const32Value>(proc, Origin(), 0));
9617		9625
9618	rare->appendNew<ControlValue>(	9626	rare->appendNewControlValue(
9619	proc, Return, Origin(),	9627	proc, Return, Origin(),
9620	rare->appendNew<CCallValue>(	9628	rare->appendNew<CCallValue>(
9621	proc, Int32, Origin(),	9629	proc, Int32, Origin(),
Lines 9633-9648 void testCallRareLive(int a, int b, int Source/JavaScriptCore/b3/testb3.cpp_sec487
9633	BasicBlock* common = proc.addBlock();	9641	BasicBlock* common = proc.addBlock();
9634	BasicBlock* rare = proc.addBlock();	9642	BasicBlock* rare = proc.addBlock();
9635		9643
9636	root->appendNew<ControlValue>(	9644	root->appendNewControlValue(
9637	proc, Branch, Origin(),	9645	proc, Branch, Origin(),
9638	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	9646	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),
9639	FrequentedBlock(rare, FrequencyClass::Rare),	9647	FrequentedBlock(rare, FrequencyClass::Rare),
9640	FrequentedBlock(common));	9648	FrequentedBlock(common));
9641		9649
9642	common->appendNew<ControlValue>(	9650	common->appendNewControlValue(
9643	proc, Return, Origin(), common->appendNew<Const32Value>(proc, Origin(), 0));	9651	proc, Return, Origin(), common->appendNew<Const32Value>(proc, Origin(), 0));
9644		9652
9645	rare->appendNew<ControlValue>(	9653	rare->appendNewControlValue(
9646	proc, Return, Origin(),	9654	proc, Return, Origin(),
9647	rare->appendNew<Value>(	9655	rare->appendNew<Value>(
9648	proc, Add, Origin(),	9656	proc, Add, Origin(),
Lines 9662-9668 void testCallSimplePure(int a, int b) Source/JavaScriptCore/b3/testb3.cpp_sec488
9662	{	9670	{
9663	Procedure proc;	9671	Procedure proc;
9664	BasicBlock* root = proc.addBlock();	9672	BasicBlock* root = proc.addBlock();
9665	root->appendNew<ControlValue>(	9673	root->appendNewControlValue(
9666	proc, Return, Origin(),	9674	proc, Return, Origin(),
9667	root->appendNew<CCallValue>(	9675	root->appendNew<CCallValue>(
9668	proc, Int32, Origin(), Effects::none(),	9676	proc, Int32, Origin(), Effects::none(),
Lines 9692-9698 void testCallFunctionWithHellaArguments( Source/JavaScriptCore/b3/testb3.cpp_sec489
9692	root->appendNew<ConstPtrValue>(proc, Origin(), bitwise_cast<void*>(functionWithHellaArguments)));	9700	root->appendNew<ConstPtrValue>(proc, Origin(), bitwise_cast<void*>(functionWithHellaArguments)));
9693	call->children().appendVector(args);	9701	call->children().appendVector(args);
9694		9702
9695	root->appendNew<ControlValue>(proc, Return, Origin(), call);	9703	root->appendNewControlValue(proc, Return, Origin(), call);
9696		9704
9697	CHECK(compileAndRun<int>(proc) == functionWithHellaArguments(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26));	9705	CHECK(compileAndRun<int>(proc) == functionWithHellaArguments(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26));
9698	}	9706	}
Lines 9701-9707 void testReturnDouble(double value) Source/JavaScriptCore/b3/testb3.cpp_sec490
9701	{	9709	{
9702	Procedure proc;	9710	Procedure proc;
9703	BasicBlock* root = proc.addBlock();	9711	BasicBlock* root = proc.addBlock();
9704	root->appendNew<ControlValue>(	9712	root->appendNewControlValue(
9705	proc, Return, Origin(),	9713	proc, Return, Origin(),
9706	root->appendNew<ConstDoubleValue>(proc, Origin(), value));	9714	root->appendNew<ConstDoubleValue>(proc, Origin(), value));
9707		9715
Lines 9712-9718 void testReturnFloat(float value) Source/JavaScriptCore/b3/testb3.cpp_sec491
9712	{	9720	{
9713	Procedure proc;	9721	Procedure proc;
9714	BasicBlock* root = proc.addBlock();	9722	BasicBlock* root = proc.addBlock();
9715	root->appendNew<ControlValue>(	9723	root->appendNewControlValue(
9716	proc, Return, Origin(),	9724	proc, Return, Origin(),
9717	root->appendNew<ConstFloatValue>(proc, Origin(), value));	9725	root->appendNew<ConstFloatValue>(proc, Origin(), value));
9718		9726
Lines 9728-9734 void testCallSimpleDouble(double a, doub Source/JavaScriptCore/b3/testb3.cpp_sec492
9728	{	9736	{
9729	Procedure proc;	9737	Procedure proc;
9730	BasicBlock* root = proc.addBlock();	9738	BasicBlock* root = proc.addBlock();
9731	root->appendNew<ControlValue>(	9739	root->appendNewControlValue(
9732	proc, Return, Origin(),	9740	proc, Return, Origin(),
9733	root->appendNew<CCallValue>(	9741	root->appendNew<CCallValue>(
9734	proc, Double, Origin(),	9742	proc, Double, Origin(),
Lines 9754-9760 void testCallSimpleFloat(float a, float Source/JavaScriptCore/b3/testb3.cpp_sec493
9754	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	9762	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
9755	Value* floatValue1 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument1int32);	9763	Value* floatValue1 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument1int32);
9756	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);	9764	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);
9757	root->appendNew<ControlValue>(	9765	root->appendNewControlValue(
9758	proc, Return, Origin(),	9766	proc, Return, Origin(),
9759	root->appendNew<CCallValue>(	9767	root->appendNew<CCallValue>(
9760	proc, Float, Origin(),	9768	proc, Float, Origin(),
Lines 9784-9790 void testCallFunctionWithHellaDoubleArgu Source/JavaScriptCore/b3/testb3.cpp_sec494
9784	root->appendNew<ConstPtrValue>(proc, Origin(), bitwise_cast<void*>(functionWithHellaDoubleArguments)));	9792	root->appendNew<ConstPtrValue>(proc, Origin(), bitwise_cast<void*>(functionWithHellaDoubleArguments)));
9785	call->children().appendVector(args);	9793	call->children().appendVector(args);
9786		9794
9787	root->appendNew<ControlValue>(proc, Return, Origin(), call);	9795	root->appendNewControlValue(proc, Return, Origin(), call);
9788		9796
9789	CHECK(compileAndRun<double>(proc) == functionWithHellaDoubleArguments(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26));	9797	CHECK(compileAndRun<double>(proc) == functionWithHellaDoubleArguments(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26));
9790	}	9798	}
Lines 9808-9814 void testCallFunctionWithHellaFloatArgum Source/JavaScriptCore/b3/testb3.cpp_sec495
9808	root->appendNew<ConstPtrValue>(proc, Origin(), bitwise_cast<void*>(functionWithHellaFloatArguments)));	9816	root->appendNew<ConstPtrValue>(proc, Origin(), bitwise_cast<void*>(functionWithHellaFloatArguments)));
9809	call->children().appendVector(args);	9817	call->children().appendVector(args);
9810		9818
9811	root->appendNew<ControlValue>(proc, Return, Origin(), call);	9819	root->appendNewControlValue(proc, Return, Origin(), call);
9812		9820
9813	CHECK(compileAndRun<float>(proc) == functionWithHellaFloatArguments(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26));	9821	CHECK(compileAndRun<float>(proc) == functionWithHellaFloatArguments(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26));
9814	}	9822	}
Lines 9820-9826 void testChillDiv(int num, int den, int Source/JavaScriptCore/b3/testb3.cpp_sec496
9820	Procedure proc;	9828	Procedure proc;
9821	BasicBlock* root = proc.addBlock();	9829	BasicBlock* root = proc.addBlock();
9822		9830
9823	root->appendNew<ControlValue>(	9831	root->appendNewControlValue(
9824	proc, Return, Origin(),	9832	proc, Return, Origin(),
9825	root->appendNew<Value>(	9833	root->appendNew<Value>(
9826	proc, ChillDiv, Origin(),	9834	proc, ChillDiv, Origin(),
Lines 9839-9845 void testChillDiv(int num, int den, int Source/JavaScriptCore/b3/testb3.cpp_sec497
9839	Procedure proc;	9847	Procedure proc;
9840	BasicBlock* root = proc.addBlock();	9848	BasicBlock* root = proc.addBlock();
9841		9849
9842	root->appendNew<ControlValue>(	9850	root->appendNewControlValue(
9843	proc, Return, Origin(),	9851	proc, Return, Origin(),
9844	root->appendNew<Value>(	9852	root->appendNew<Value>(
9845	proc, ChillDiv, Origin(),	9853	proc, ChillDiv, Origin(),
Lines 9855-9861 void testChillDivTwice(int num1, int den Source/JavaScriptCore/b3/testb3.cpp_sec498
9855	Procedure proc;	9863	Procedure proc;
9856	BasicBlock* root = proc.addBlock();	9864	BasicBlock* root = proc.addBlock();
9857		9865
9858	root->appendNew<ControlValue>(	9866	root->appendNewControlValue(
9859	proc, Return, Origin(),	9867	proc, Return, Origin(),
9860	root->appendNew<Value>(	9868	root->appendNew<Value>(
9861	proc, Add, Origin(),	9869	proc, Add, Origin(),
Lines 9889-9895 void testChillDiv64(int64_t num, int64_t Source/JavaScriptCore/b3/testb3.cpp_sec499
9889	Procedure proc;	9897	Procedure proc;
9890	BasicBlock* root = proc.addBlock();	9898	BasicBlock* root = proc.addBlock();
9891		9899
9892	root->appendNew<ControlValue>(	9900	root->appendNewControlValue(
9893	proc, Return, Origin(),	9901	proc, Return, Origin(),
9894	root->appendNew<Value>(	9902	root->appendNew<Value>(
9895	proc, ChillDiv, Origin(),	9903	proc, ChillDiv, Origin(),
Lines 9904-9910 void testChillDiv64(int64_t num, int64_t Source/JavaScriptCore/b3/testb3.cpp_sec500
9904	Procedure proc;	9912	Procedure proc;
9905	BasicBlock* root = proc.addBlock();	9913	BasicBlock* root = proc.addBlock();
9906		9914
9907	root->appendNew<ControlValue>(	9915	root->appendNewControlValue(
9908	proc, Return, Origin(),	9916	proc, Return, Origin(),
9909	root->appendNew<Value>(	9917	root->appendNew<Value>(
9910	proc, ChillDiv, Origin(),	9918	proc, ChillDiv, Origin(),
Lines 9925-9931 void testModArg(int64_t value) Source/JavaScriptCore/b3/testb3.cpp_sec501
9925		9933
9926	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	9934	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
9927	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument, argument);	9935	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument, argument);
9928	root->appendNew<ControlValue>(proc, Return, Origin(), result);	9936	root->appendNewControlValue(proc, Return, Origin(), result);
9929		9937
9930	CHECK(!compileAndRun<int64_t>(proc, value));	9938	CHECK(!compileAndRun<int64_t>(proc, value));
9931	}	9939	}
Lines 9943-9949 void testModArgs(int64_t numerator, int6 Source/JavaScriptCore/b3/testb3.cpp_sec502
9943	Value* argument1 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	9951	Value* argument1 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
9944	Value* argument2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	9952	Value* argument2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
9945	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument1, argument2);	9953	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument1, argument2);
9946	root->appendNew<ControlValue>(proc, Return, Origin(), result);	9954	root->appendNewControlValue(proc, Return, Origin(), result);
9947		9955
9948	CHECK(compileAndRun<int64_t>(proc, numerator, denominator) == numerator % denominator);	9956	CHECK(compileAndRun<int64_t>(proc, numerator, denominator) == numerator % denominator);
9949	}	9957	}
Lines 9961-9967 void testModImms(int64_t numerator, int6 Source/JavaScriptCore/b3/testb3.cpp_sec503
9961	Value* argument1 = root->appendNew<Const64Value>(proc, Origin(), numerator);	9969	Value* argument1 = root->appendNew<Const64Value>(proc, Origin(), numerator);
9962	Value* argument2 = root->appendNew<Const64Value>(proc, Origin(), denominator);	9970	Value* argument2 = root->appendNew<Const64Value>(proc, Origin(), denominator);
9963	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument1, argument2);	9971	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument1, argument2);
9964	root->appendNew<ControlValue>(proc, Return, Origin(), result);	9972	root->appendNewControlValue(proc, Return, Origin(), result);
9965		9973
9966	CHECK(compileAndRun<int64_t>(proc, numerator, denominator) == numerator % denominator);	9974	CHECK(compileAndRun<int64_t>(proc, numerator, denominator) == numerator % denominator);
9967	}	9975	}
Lines 9977-9983 void testModArg32(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec504
9977	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),	9985	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),
9978	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	9986	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
9979	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument, argument);	9987	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument, argument);
9980	root->appendNew<ControlValue>(proc, Return, Origin(), result);	9988	root->appendNewControlValue(proc, Return, Origin(), result);
9981		9989
9982	CHECK(!compileAndRun<int32_t>(proc, value));	9990	CHECK(!compileAndRun<int32_t>(proc, value));
9983	}	9991	}
Lines 9997-10003 void testModArgs32(int32_t numerator, in Source/JavaScriptCore/b3/testb3.cpp_sec505
9997	Value* argument2 = root->appendNew<Value>(proc, Trunc, Origin(),	10005	Value* argument2 = root->appendNew<Value>(proc, Trunc, Origin(),
9998	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	10006	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
9999	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument1, argument2);	10007	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument1, argument2);
10000	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10008	root->appendNewControlValue(proc, Return, Origin(), result);
10001		10009
10002	CHECK(compileAndRun<int32_t>(proc, numerator, denominator) == numerator % denominator);	10010	CHECK(compileAndRun<int32_t>(proc, numerator, denominator) == numerator % denominator);
10003	}	10011	}
Lines 10015-10021 void testModImms32(int32_t numerator, in Source/JavaScriptCore/b3/testb3.cpp_sec506
10015	Value* argument1 = root->appendNew<Const32Value>(proc, Origin(), numerator);	10023	Value* argument1 = root->appendNew<Const32Value>(proc, Origin(), numerator);
10016	Value* argument2 = root->appendNew<Const32Value>(proc, Origin(), denominator);	10024	Value* argument2 = root->appendNew<Const32Value>(proc, Origin(), denominator);
10017	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument1, argument2);	10025	Value* result = root->appendNew<Value>(proc, Mod, Origin(), argument1, argument2);
10018	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10026	root->appendNewControlValue(proc, Return, Origin(), result);
10019		10027
10020	CHECK(compileAndRun<int32_t>(proc, numerator, denominator) == numerator % denominator);	10028	CHECK(compileAndRun<int32_t>(proc, numerator, denominator) == numerator % denominator);
10021	}	10029	}
Lines 10027-10033 void testChillModArg(int64_t value) Source/JavaScriptCore/b3/testb3.cpp_sec507
10027		10035
10028	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	10036	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
10029	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument, argument);	10037	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument, argument);
10030	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10038	root->appendNewControlValue(proc, Return, Origin(), result);
10031		10039
10032	CHECK(!compileAndRun<int64_t>(proc, value));	10040	CHECK(!compileAndRun<int64_t>(proc, value));
10033	}	10041	}
Lines 10040-10046 void testChillModArgs(int64_t numerator, Source/JavaScriptCore/b3/testb3.cpp_sec508
10040	Value* argument1 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	10048	Value* argument1 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
10041	Value* argument2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	10049	Value* argument2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
10042	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument1, argument2);	10050	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument1, argument2);
10043	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10051	root->appendNewControlValue(proc, Return, Origin(), result);
10044		10052
10045	CHECK(compileAndRun<int64_t>(proc, numerator, denominator) == chillMod(numerator, denominator));	10053	CHECK(compileAndRun<int64_t>(proc, numerator, denominator) == chillMod(numerator, denominator));
10046	}	10054	}
Lines 10053-10059 void testChillModImms(int64_t numerator, Source/JavaScriptCore/b3/testb3.cpp_sec509
10053	Value* argument1 = root->appendNew<Const64Value>(proc, Origin(), numerator);	10061	Value* argument1 = root->appendNew<Const64Value>(proc, Origin(), numerator);
10054	Value* argument2 = root->appendNew<Const64Value>(proc, Origin(), denominator);	10062	Value* argument2 = root->appendNew<Const64Value>(proc, Origin(), denominator);
10055	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument1, argument2);	10063	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument1, argument2);
10056	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10064	root->appendNewControlValue(proc, Return, Origin(), result);
10057		10065
10058	CHECK(compileAndRun<int64_t>(proc, numerator, denominator) == chillMod(numerator, denominator));	10066	CHECK(compileAndRun<int64_t>(proc, numerator, denominator) == chillMod(numerator, denominator));
10059	}	10067	}
Lines 10066-10072 void testChillModArg32(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec510
10066	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),	10074	Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),
10067	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	10075	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
10068	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument, argument);	10076	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument, argument);
10069	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10077	root->appendNewControlValue(proc, Return, Origin(), result);
10070		10078
10071	CHECK(!compileAndRun<int32_t>(proc, value));	10079	CHECK(!compileAndRun<int32_t>(proc, value));
10072	}	10080	}
Lines 10081-10087 void testChillModArgs32(int32_t numerato Source/JavaScriptCore/b3/testb3.cpp_sec511
10081	Value* argument2 = root->appendNew<Value>(proc, Trunc, Origin(),	10089	Value* argument2 = root->appendNew<Value>(proc, Trunc, Origin(),
10082	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));	10090	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
10083	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument1, argument2);	10091	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument1, argument2);
10084	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10092	root->appendNewControlValue(proc, Return, Origin(), result);
10085		10093
10086	CHECK(compileAndRun<int32_t>(proc, numerator, denominator) == chillMod(numerator, denominator));	10094	CHECK(compileAndRun<int32_t>(proc, numerator, denominator) == chillMod(numerator, denominator));
10087	}	10095	}
Lines 10094-10100 void testChillModImms32(int32_t numerato Source/JavaScriptCore/b3/testb3.cpp_sec512
10094	Value* argument1 = root->appendNew<Const32Value>(proc, Origin(), numerator);	10102	Value* argument1 = root->appendNew<Const32Value>(proc, Origin(), numerator);
10095	Value* argument2 = root->appendNew<Const32Value>(proc, Origin(), denominator);	10103	Value* argument2 = root->appendNew<Const32Value>(proc, Origin(), denominator);
10096	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument1, argument2);	10104	Value* result = root->appendNew<Value>(proc, ChillMod, Origin(), argument1, argument2);
10097	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10105	root->appendNewControlValue(proc, Return, Origin(), result);
10098		10106
10099	CHECK(compileAndRun<int32_t>(proc, numerator, denominator) == chillMod(numerator, denominator));	10107	CHECK(compileAndRun<int32_t>(proc, numerator, denominator) == chillMod(numerator, denominator));
10100	}	10108	}
Lines 10105-10122 void testSwitch(unsigned degree, unsigne Source/JavaScriptCore/b3/testb3.cpp_sec513
10105	BasicBlock* root = proc.addBlock();	10113	BasicBlock* root = proc.addBlock();
10106		10114
10107	BasicBlock* terminate = proc.addBlock();	10115	BasicBlock* terminate = proc.addBlock();
10108	terminate->appendNew<ControlValue>(	10116	terminate->appendNewControlValue(
10109	proc, Return, Origin(),	10117	proc, Return, Origin(),
10110	terminate->appendNew<Const32Value>(proc, Origin(), 0));	10118	terminate->appendNew<Const32Value>(proc, Origin(), 0));
10111		10119
10112	SwitchValue* switchValue = root->appendNew<SwitchValue>(	10120	SwitchValue* switchValue = root->appendNew<SwitchValue>(
10113	proc, Origin(),	10121	proc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
10114	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	10122	switchValue->setFallThrough(FrequentedBlock(terminate));
10115	FrequentedBlock(terminate));
10116		10123
10117	for (unsigned i = 0; i < degree; ++i) {	10124	for (unsigned i = 0; i < degree; ++i) {
10118	BasicBlock* newBlock = proc.addBlock();	10125	BasicBlock* newBlock = proc.addBlock();
10119	newBlock->appendNew<ControlValue>(	10126	newBlock->appendNewControlValue(
10120	proc, Return, Origin(),	10127	proc, Return, Origin(),
10121	newBlock->appendNew<ArgumentRegValue>(	10128	newBlock->appendNew<ArgumentRegValue>(
10122	proc, Origin(), (i & 1) ? GPRInfo::argumentGPR2 : GPRInfo::argumentGPR1));	10129	proc, Origin(), (i & 1) ? GPRInfo::argumentGPR2 : GPRInfo::argumentGPR1));
Lines 10147-10165 void testSwitchChillDiv(unsigned degree, Source/JavaScriptCore/b3/testb3.cpp_sec514
10147	Value* right = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);	10154	Value* right = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
10148		10155
10149	BasicBlock* terminate = proc.addBlock();	10156	BasicBlock* terminate = proc.addBlock();
10150	terminate->appendNew<ControlValue>(	10157	terminate->appendNewControlValue(
10151	proc, Return, Origin(),	10158	proc, Return, Origin(),
10152	terminate->appendNew<Const32Value>(proc, Origin(), 0));	10159	terminate->appendNew<Const32Value>(proc, Origin(), 0));
10153		10160
10154	SwitchValue* switchValue = root->appendNew<SwitchValue>(	10161	SwitchValue* switchValue = root->appendNew<SwitchValue>(
10155	proc, Origin(),	10162	proc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
10156	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	10163	switchValue->setFallThrough(FrequentedBlock(terminate));
10157	FrequentedBlock(terminate));
10158		10164
10159	for (unsigned i = 0; i < degree; ++i) {	10165	for (unsigned i = 0; i < degree; ++i) {
10160	BasicBlock* newBlock = proc.addBlock();	10166	BasicBlock* newBlock = proc.addBlock();
10161		10167
10162	newBlock->appendNew<ControlValue>(	10168	newBlock->appendNewControlValue(
10163	proc, Return, Origin(),	10169	proc, Return, Origin(),
10164	newBlock->appendNew<Value>(	10170	newBlock->appendNew<Value>(
10165	proc, ChillDiv, Origin(), (i & 1) ? right : left, (i & 1) ? left : right));	10171	proc, ChillDiv, Origin(), (i & 1) ? right : left, (i & 1) ? left : right));
Lines 10170-10176 void testSwitchChillDiv(unsigned degree, Source/JavaScriptCore/b3/testb3.cpp_sec515
10170	auto code = compile(proc);	10176	auto code = compile(proc);
10171		10177
10172	for (unsigned i = 0; i < degree; ++i) {	10178	for (unsigned i = 0; i < degree; ++i) {
10173	CHECK(invoke<int32_t>(code, i gap, 42, 11) == ((i & 1) ? 11/42 : 42/11));	10179	dataLog("i = ", i, "\n");
		10180	int32_t result = invoke<int32_t>(code, i gap, 42, 11);
		10181	dataLog("result = ", result, "\n");
		10182	CHECK(result == ((i & 1) ? 11/42 : 42/11));
10174	if (gap > 1) {	10183	if (gap > 1) {
10175	CHECK(!invoke<int32_t>(code, i gap + 1, 42, 11));	10184	CHECK(!invoke<int32_t>(code, i gap + 1, 42, 11));
10176	CHECK(!invoke<int32_t>(code, i gap - 1, 42, 11));	10185	CHECK(!invoke<int32_t>(code, i gap - 1, 42, 11));
Lines 10188-10204 void testSwitchTargettingSameBlock() Source/JavaScriptCore/b3/testb3.cpp_sec516
10188	BasicBlock* root = proc.addBlock();	10197	BasicBlock* root = proc.addBlock();
10189		10198
10190	BasicBlock* terminate = proc.addBlock();	10199	BasicBlock* terminate = proc.addBlock();
10191	terminate->appendNew<ControlValue>(	10200	terminate->appendNewControlValue(
10192	proc, Return, Origin(),	10201	proc, Return, Origin(),
10193	terminate->appendNew<Const32Value>(proc, Origin(), 5));	10202	terminate->appendNew<Const32Value>(proc, Origin(), 5));
10194		10203
10195	SwitchValue* switchValue = root->appendNew<SwitchValue>(	10204	SwitchValue* switchValue = root->appendNew<SwitchValue>(
10196	proc, Origin(),	10205	proc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
10197	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0),	10206	switchValue->setFallThrough(FrequentedBlock(terminate));
10198	FrequentedBlock(terminate));
10199		10207
10200	BasicBlock* otherTarget = proc.addBlock();	10208	BasicBlock* otherTarget = proc.addBlock();
10201	otherTarget->appendNew<ControlValue>(	10209	otherTarget->appendNewControlValue(
10202	proc, Return, Origin(),	10210	proc, Return, Origin(),
10203	otherTarget->appendNew<Const32Value>(proc, Origin(), 42));	10211	otherTarget->appendNew<Const32Value>(proc, Origin(), 42));
10204	switchValue->appendCase(SwitchCase(3, FrequentedBlock(otherTarget)));	10212	switchValue->appendCase(SwitchCase(3, FrequentedBlock(otherTarget)));
Lines 10218-10235 void testSwitchTargettingSameBlockFoldPa Source/JavaScriptCore/b3/testb3.cpp_sec517
10218	BasicBlock* root = proc.addBlock();	10226	BasicBlock* root = proc.addBlock();
10219		10227
10220	BasicBlock* terminate = proc.addBlock();	10228	BasicBlock* terminate = proc.addBlock();
10221	terminate->appendNew<ControlValue>(	10229	terminate->appendNewControlValue(
10222	proc, Return, Origin(),	10230	proc, Return, Origin(),
10223	terminate->appendNew<Const32Value>(proc, Origin(), 42));	10231	terminate->appendNew<Const32Value>(proc, Origin(), 42));
10224		10232
10225	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	10233	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
10226	SwitchValue* switchValue = root->appendNew<SwitchValue>(	10234	SwitchValue* switchValue = root->appendNew<SwitchValue>(proc, Origin(), argument);
10227	proc, Origin(),	10235	switchValue->setFallThrough(FrequentedBlock(terminate));
10228	argument,
10229	FrequentedBlock(terminate));
10230		10236
10231	BasicBlock* otherTarget = proc.addBlock();	10237	BasicBlock* otherTarget = proc.addBlock();
10232	otherTarget->appendNew<ControlValue>(	10238	otherTarget->appendNewControlValue(
10233	proc, Return, Origin(), argument);	10239	proc, Return, Origin(), argument);
10234	switchValue->appendCase(SwitchCase(3, FrequentedBlock(otherTarget)));	10240	switchValue->appendCase(SwitchCase(3, FrequentedBlock(otherTarget)));
10235	switchValue->appendCase(SwitchCase(13, FrequentedBlock(otherTarget)));	10241	switchValue->appendCase(SwitchCase(13, FrequentedBlock(otherTarget)));
Lines 10246-10252 void testTruncFold(int64_t value) Source/JavaScriptCore/b3/testb3.cpp_sec518
10246	{	10252	{
10247	Procedure proc;	10253	Procedure proc;
10248	BasicBlock* root = proc.addBlock();	10254	BasicBlock* root = proc.addBlock();
10249	root->appendNew<ControlValue>(	10255	root->appendNewControlValue(
10250	proc, Return, Origin(),	10256	proc, Return, Origin(),
10251	root->appendNew<Value>(	10257	root->appendNew<Value>(
10252	proc, Trunc, Origin(),	10258	proc, Trunc, Origin(),
Lines 10259-10265 void testZExt32(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec519
10259	{	10265	{
10260	Procedure proc;	10266	Procedure proc;
10261	BasicBlock* root = proc.addBlock();	10267	BasicBlock* root = proc.addBlock();
10262	root->appendNew<ControlValue>(	10268	root->appendNewControlValue(
10263	proc, Return, Origin(),	10269	proc, Return, Origin(),
10264	root->appendNew<Value>(	10270	root->appendNew<Value>(
10265	proc, ZExt32, Origin(),	10271	proc, ZExt32, Origin(),
Lines 10274-10280 void testZExt32Fold(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec520
10274	{	10280	{
10275	Procedure proc;	10281	Procedure proc;
10276	BasicBlock* root = proc.addBlock();	10282	BasicBlock* root = proc.addBlock();
10277	root->appendNew<ControlValue>(	10283	root->appendNewControlValue(
10278	proc, Return, Origin(),	10284	proc, Return, Origin(),
10279	root->appendNew<Value>(	10285	root->appendNew<Value>(
10280	proc, ZExt32, Origin(),	10286	proc, ZExt32, Origin(),
Lines 10287-10293 void testSExt32(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec521
10287	{	10293	{
10288	Procedure proc;	10294	Procedure proc;
10289	BasicBlock* root = proc.addBlock();	10295	BasicBlock* root = proc.addBlock();
10290	root->appendNew<ControlValue>(	10296	root->appendNewControlValue(
10291	proc, Return, Origin(),	10297	proc, Return, Origin(),
10292	root->appendNew<Value>(	10298	root->appendNew<Value>(
10293	proc, SExt32, Origin(),	10299	proc, SExt32, Origin(),
Lines 10302-10308 void testSExt32Fold(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec522
10302	{	10308	{
10303	Procedure proc;	10309	Procedure proc;
10304	BasicBlock* root = proc.addBlock();	10310	BasicBlock* root = proc.addBlock();
10305	root->appendNew<ControlValue>(	10311	root->appendNewControlValue(
10306	proc, Return, Origin(),	10312	proc, Return, Origin(),
10307	root->appendNew<Value>(	10313	root->appendNew<Value>(
10308	proc, SExt32, Origin(),	10314	proc, SExt32, Origin(),
Lines 10315-10321 void testTruncZExt32(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec523
10315	{	10321	{
10316	Procedure proc;	10322	Procedure proc;
10317	BasicBlock* root = proc.addBlock();	10323	BasicBlock* root = proc.addBlock();
10318	root->appendNew<ControlValue>(	10324	root->appendNewControlValue(
10319	proc, Return, Origin(),	10325	proc, Return, Origin(),
10320	root->appendNew<Value>(	10326	root->appendNew<Value>(
10321	proc, Trunc, Origin(),	10327	proc, Trunc, Origin(),
Lines 10332-10338 void testTruncSExt32(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec524
10332	{	10338	{
10333	Procedure proc;	10339	Procedure proc;
10334	BasicBlock* root = proc.addBlock();	10340	BasicBlock* root = proc.addBlock();
10335	root->appendNew<ControlValue>(	10341	root->appendNewControlValue(
10336	proc, Return, Origin(),	10342	proc, Return, Origin(),
10337	root->appendNew<Value>(	10343	root->appendNew<Value>(
10338	proc, Trunc, Origin(),	10344	proc, Trunc, Origin(),
Lines 10349-10355 void testSExt8(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec525
10349	{	10355	{
10350	Procedure proc;	10356	Procedure proc;
10351	BasicBlock* root = proc.addBlock();	10357	BasicBlock* root = proc.addBlock();
10352	root->appendNew<ControlValue>(	10358	root->appendNewControlValue(
10353	proc, Return, Origin(),	10359	proc, Return, Origin(),
10354	root->appendNew<Value>(	10360	root->appendNew<Value>(
10355	proc, SExt8, Origin(),	10361	proc, SExt8, Origin(),
Lines 10364-10370 void testSExt8Fold(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec526
10364	{	10370	{
10365	Procedure proc;	10371	Procedure proc;
10366	BasicBlock* root = proc.addBlock();	10372	BasicBlock* root = proc.addBlock();
10367	root->appendNew<ControlValue>(	10373	root->appendNewControlValue(
10368	proc, Return, Origin(),	10374	proc, Return, Origin(),
10369	root->appendNew<Value>(	10375	root->appendNew<Value>(
10370	proc, SExt8, Origin(),	10376	proc, SExt8, Origin(),
Lines 10377-10383 void testSExt8SExt8(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec527
10377	{	10383	{
10378	Procedure proc;	10384	Procedure proc;
10379	BasicBlock* root = proc.addBlock();	10385	BasicBlock* root = proc.addBlock();
10380	root->appendNew<ControlValue>(	10386	root->appendNewControlValue(
10381	proc, Return, Origin(),	10387	proc, Return, Origin(),
10382	root->appendNew<Value>(	10388	root->appendNew<Value>(
10383	proc, SExt8, Origin(),	10389	proc, SExt8, Origin(),
Lines 10394-10400 void testSExt8SExt16(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec528
10394	{	10400	{
10395	Procedure proc;	10401	Procedure proc;
10396	BasicBlock* root = proc.addBlock();	10402	BasicBlock* root = proc.addBlock();
10397	root->appendNew<ControlValue>(	10403	root->appendNewControlValue(
10398	proc, Return, Origin(),	10404	proc, Return, Origin(),
10399	root->appendNew<Value>(	10405	root->appendNew<Value>(
10400	proc, SExt8, Origin(),	10406	proc, SExt8, Origin(),
Lines 10411-10417 void testSExt8BitAnd(int32_t value, int3 Source/JavaScriptCore/b3/testb3.cpp_sec529
10411	{	10417	{
10412	Procedure proc;	10418	Procedure proc;
10413	BasicBlock* root = proc.addBlock();	10419	BasicBlock* root = proc.addBlock();
10414	root->appendNew<ControlValue>(	10420	root->appendNewControlValue(
10415	proc, Return, Origin(),	10421	proc, Return, Origin(),
10416	root->appendNew<Value>(	10422	root->appendNew<Value>(
10417	proc, SExt8, Origin(),	10423	proc, SExt8, Origin(),
Lines 10429-10435 void testBitAndSExt8(int32_t value, int3 Source/JavaScriptCore/b3/testb3.cpp_sec530
10429	{	10435	{
10430	Procedure proc;	10436	Procedure proc;
10431	BasicBlock* root = proc.addBlock();	10437	BasicBlock* root = proc.addBlock();
10432	root->appendNew<ControlValue>(	10438	root->appendNewControlValue(
10433	proc, Return, Origin(),	10439	proc, Return, Origin(),
10434	root->appendNew<Value>(	10440	root->appendNew<Value>(
10435	proc, BitAnd, Origin(),	10441	proc, BitAnd, Origin(),
Lines 10447-10453 void testSExt16(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec531
10447	{	10453	{
10448	Procedure proc;	10454	Procedure proc;
10449	BasicBlock* root = proc.addBlock();	10455	BasicBlock* root = proc.addBlock();
10450	root->appendNew<ControlValue>(	10456	root->appendNewControlValue(
10451	proc, Return, Origin(),	10457	proc, Return, Origin(),
10452	root->appendNew<Value>(	10458	root->appendNew<Value>(
10453	proc, SExt16, Origin(),	10459	proc, SExt16, Origin(),
Lines 10462-10468 void testSExt16Fold(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec532
10462	{	10468	{
10463	Procedure proc;	10469	Procedure proc;
10464	BasicBlock* root = proc.addBlock();	10470	BasicBlock* root = proc.addBlock();
10465	root->appendNew<ControlValue>(	10471	root->appendNewControlValue(
10466	proc, Return, Origin(),	10472	proc, Return, Origin(),
10467	root->appendNew<Value>(	10473	root->appendNew<Value>(
10468	proc, SExt16, Origin(),	10474	proc, SExt16, Origin(),
Lines 10475-10481 void testSExt16SExt16(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec533
10475	{	10481	{
10476	Procedure proc;	10482	Procedure proc;
10477	BasicBlock* root = proc.addBlock();	10483	BasicBlock* root = proc.addBlock();
10478	root->appendNew<ControlValue>(	10484	root->appendNewControlValue(
10479	proc, Return, Origin(),	10485	proc, Return, Origin(),
10480	root->appendNew<Value>(	10486	root->appendNew<Value>(
10481	proc, SExt16, Origin(),	10487	proc, SExt16, Origin(),
Lines 10492-10498 void testSExt16SExt8(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec534
10492	{	10498	{
10493	Procedure proc;	10499	Procedure proc;
10494	BasicBlock* root = proc.addBlock();	10500	BasicBlock* root = proc.addBlock();
10495	root->appendNew<ControlValue>(	10501	root->appendNewControlValue(
10496	proc, Return, Origin(),	10502	proc, Return, Origin(),
10497	root->appendNew<Value>(	10503	root->appendNew<Value>(
10498	proc, SExt16, Origin(),	10504	proc, SExt16, Origin(),
Lines 10509-10515 void testSExt16BitAnd(int32_t value, int Source/JavaScriptCore/b3/testb3.cpp_sec535
10509	{	10515	{
10510	Procedure proc;	10516	Procedure proc;
10511	BasicBlock* root = proc.addBlock();	10517	BasicBlock* root = proc.addBlock();
10512	root->appendNew<ControlValue>(	10518	root->appendNewControlValue(
10513	proc, Return, Origin(),	10519	proc, Return, Origin(),
10514	root->appendNew<Value>(	10520	root->appendNew<Value>(
10515	proc, SExt16, Origin(),	10521	proc, SExt16, Origin(),
Lines 10527-10533 void testBitAndSExt16(int32_t value, int Source/JavaScriptCore/b3/testb3.cpp_sec536
10527	{	10533	{
10528	Procedure proc;	10534	Procedure proc;
10529	BasicBlock* root = proc.addBlock();	10535	BasicBlock* root = proc.addBlock();
10530	root->appendNew<ControlValue>(	10536	root->appendNewControlValue(
10531	proc, Return, Origin(),	10537	proc, Return, Origin(),
10532	root->appendNew<Value>(	10538	root->appendNew<Value>(
10533	proc, BitAnd, Origin(),	10539	proc, BitAnd, Origin(),
Lines 10545-10551 void testSExt32BitAnd(int32_t value, int Source/JavaScriptCore/b3/testb3.cpp_sec537
10545	{	10551	{
10546	Procedure proc;	10552	Procedure proc;
10547	BasicBlock* root = proc.addBlock();	10553	BasicBlock* root = proc.addBlock();
10548	root->appendNew<ControlValue>(	10554	root->appendNewControlValue(
10549	proc, Return, Origin(),	10555	proc, Return, Origin(),
10550	root->appendNew<Value>(	10556	root->appendNew<Value>(
10551	proc, SExt32, Origin(),	10557	proc, SExt32, Origin(),
Lines 10563-10569 void testBitAndSExt32(int32_t value, int Source/JavaScriptCore/b3/testb3.cpp_sec538
10563	{	10569	{
10564	Procedure proc;	10570	Procedure proc;
10565	BasicBlock* root = proc.addBlock();	10571	BasicBlock* root = proc.addBlock();
10566	root->appendNew<ControlValue>(	10572	root->appendNewControlValue(
10567	proc, Return, Origin(),	10573	proc, Return, Origin(),
10568	root->appendNew<Value>(	10574	root->appendNew<Value>(
10569	proc, BitAnd, Origin(),	10575	proc, BitAnd, Origin(),
Lines 10581-10587 void testBasicSelect() Source/JavaScriptCore/b3/testb3.cpp_sec539
10581	{	10587	{
10582	Procedure proc;	10588	Procedure proc;
10583	BasicBlock* root = proc.addBlock();	10589	BasicBlock* root = proc.addBlock();
10584	root->appendNew<ControlValue>(	10590	root->appendNewControlValue(
10585	proc, Return, Origin(),	10591	proc, Return, Origin(),
10586	root->appendNew<Value>(	10592	root->appendNew<Value>(
10587	proc, Select, Origin(),	10593	proc, Select, Origin(),
Lines 10603-10609 void testSelectTest() Source/JavaScriptCore/b3/testb3.cpp_sec540
10603	{	10609	{
10604	Procedure proc;	10610	Procedure proc;
10605	BasicBlock* root = proc.addBlock();	10611	BasicBlock* root = proc.addBlock();
10606	root->appendNew<ControlValue>(	10612	root->appendNewControlValue(
10607	proc, Return, Origin(),	10613	proc, Return, Origin(),
10608	root->appendNew<Value>(	10614	root->appendNew<Value>(
10609	proc, Select, Origin(),	10615	proc, Select, Origin(),
Lines 10622-10628 void testSelectCompareDouble() Source/JavaScriptCore/b3/testb3.cpp_sec541
10622	{	10628	{
10623	Procedure proc;	10629	Procedure proc;
10624	BasicBlock* root = proc.addBlock();	10630	BasicBlock* root = proc.addBlock();
10625	root->appendNew<ControlValue>(	10631	root->appendNewControlValue(
10626	proc, Return, Origin(),	10632	proc, Return, Origin(),
10627	root->appendNew<Value>(	10633	root->appendNew<Value>(
10628	proc, Select, Origin(),	10634	proc, Select, Origin(),
Lines 10653-10659 void testSelectCompareFloat(float a, flo Source/JavaScriptCore/b3/testb3.cpp_sec542
10653	Value* floatValue1 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument1int32);	10659	Value* floatValue1 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument1int32);
10654	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);	10660	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);
10655		10661
10656	root->appendNew<ControlValue>(	10662	root->appendNewControlValue(
10657	proc, Return, Origin(),	10663	proc, Return, Origin(),
10658	root->appendNew<Value>(	10664	root->appendNew<Value>(
10659	proc, Select, Origin(),	10665	proc, Select, Origin(),
Lines 10691-10697 void testSelectCompareFloatToDouble(floa Source/JavaScriptCore/b3/testb3.cpp_sec543
10691	Value* doubleValue1 = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue1);	10697	Value* doubleValue1 = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue1);
10692	Value* doubleValue2 = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue2);	10698	Value* doubleValue2 = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue2);
10693		10699
10694	root->appendNew<ControlValue>(	10700	root->appendNewControlValue(
10695	proc, Return, Origin(),	10701	proc, Return, Origin(),
10696	root->appendNew<Value>(	10702	root->appendNew<Value>(
10697	proc, Select, Origin(),	10703	proc, Select, Origin(),
Lines 10719-10725 void testSelectDouble() Source/JavaScriptCore/b3/testb3.cpp_sec544
10719	{	10725	{
10720	Procedure proc;	10726	Procedure proc;
10721	BasicBlock* root = proc.addBlock();	10727	BasicBlock* root = proc.addBlock();
10722	root->appendNew<ControlValue>(	10728	root->appendNewControlValue(
10723	proc, Return, Origin(),	10729	proc, Return, Origin(),
10724	root->appendNew<Value>(	10730	root->appendNew<Value>(
10725	proc, Select, Origin(),	10731	proc, Select, Origin(),
Lines 10741-10747 void testSelectDoubleTest() Source/JavaScriptCore/b3/testb3.cpp_sec545
10741	{	10747	{
10742	Procedure proc;	10748	Procedure proc;
10743	BasicBlock* root = proc.addBlock();	10749	BasicBlock* root = proc.addBlock();
10744	root->appendNew<ControlValue>(	10750	root->appendNewControlValue(
10745	proc, Return, Origin(),	10751	proc, Return, Origin(),
10746	root->appendNew<Value>(	10752	root->appendNew<Value>(
10747	proc, Select, Origin(),	10753	proc, Select, Origin(),
Lines 10760-10766 void testSelectDoubleCompareDouble() Source/JavaScriptCore/b3/testb3.cpp_sec546
10760	{	10766	{
10761	Procedure proc;	10767	Procedure proc;
10762	BasicBlock* root = proc.addBlock();	10768	BasicBlock* root = proc.addBlock();
10763	root->appendNew<ControlValue>(	10769	root->appendNewControlValue(
10764	proc, Return, Origin(),	10770	proc, Return, Origin(),
10765	root->appendNew<Value>(	10771	root->appendNew<Value>(
10766	proc, Select, Origin(),	10772	proc, Select, Origin(),
Lines 10790-10796 void testSelectDoubleCompareFloat(float Source/JavaScriptCore/b3/testb3.cpp_sec547
10790	Value* floatValue1 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument1int32);	10796	Value* floatValue1 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument1int32);
10791	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);	10797	Value* floatValue2 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument2int32);
10792		10798
10793	root->appendNew<ControlValue>(	10799	root->appendNewControlValue(
10794	proc, Return, Origin(),	10800	proc, Return, Origin(),
10795	root->appendNew<Value>(	10801	root->appendNew<Value>(
10796	proc, Select, Origin(),	10802	proc, Select, Origin(),
Lines 10821-10827 void testSelectFloatCompareFloat(float a Source/JavaScriptCore/b3/testb3.cpp_sec548
10821	Value* floatValue3 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument3int32);	10827	Value* floatValue3 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument3int32);
10822	Value* floatValue4 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument4int32);	10828	Value* floatValue4 = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument4int32);
10823		10829
10824	root->appendNew<ControlValue>(	10830	root->appendNewControlValue(
10825	proc, Return, Origin(),	10831	proc, Return, Origin(),
10826	root->appendNew<Value>(	10832	root->appendNew<Value>(
10827	proc, Select, Origin(),	10833	proc, Select, Origin(),
Lines 10847-10853 void testSelectDoubleCompareDouble(bool Source/JavaScriptCore/b3/testb3.cpp_sec549
10847	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR2);	10853	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR2);
10848	Value* arg3 = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR3);	10854	Value* arg3 = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR3);
10849		10855
10850	root->appendNew<ControlValue>(	10856	root->appendNewControlValue(
10851	proc, Return, Origin(),	10857	proc, Return, Origin(),
10852	root->appendNew<Value>(	10858	root->appendNew<Value>(
10853	proc, Select, Origin(),	10859	proc, Select, Origin(),
Lines 10883-10889 void testSelectDoubleCompareDouble(bool Source/JavaScriptCore/b3/testb3.cpp_sec550
10883	keepValuesLive->append(ConstrainedValue(arg2, ValueRep::SomeRegister));	10889	keepValuesLive->append(ConstrainedValue(arg2, ValueRep::SomeRegister));
10884	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	10890	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
10885		10891
10886	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10892	root->appendNewControlValue(proc, Return, Origin(), result);
10887	auto code = compile(proc);	10893	auto code = compile(proc);
10888		10894
10889	for (auto& left : floatingPointOperands<double>()) {	10895	for (auto& left : floatingPointOperands<double>()) {
Lines 10910-10916 void testSelectDoubleCompareDouble(bool Source/JavaScriptCore/b3/testb3.cpp_sec551
10910	keepValuesLive->append(ConstrainedValue(arg3, ValueRep::SomeRegister));	10916	keepValuesLive->append(ConstrainedValue(arg3, ValueRep::SomeRegister));
10911	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	10917	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
10912		10918
10913	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10919	root->appendNewControlValue(proc, Return, Origin(), result);
10914	auto code = compile(proc);	10920	auto code = compile(proc);
10915		10921
10916	for (auto& left : floatingPointOperands<double>()) {	10922	for (auto& left : floatingPointOperands<double>()) {
Lines 10938-10944 void testSelectDoubleCompareDouble(bool Source/JavaScriptCore/b3/testb3.cpp_sec552
10938	keepValuesLive->append(ConstrainedValue(arg3, ValueRep::SomeRegister));	10944	keepValuesLive->append(ConstrainedValue(arg3, ValueRep::SomeRegister));
10939	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	10945	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
10940		10946
10941	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10947	root->appendNewControlValue(proc, Return, Origin(), result);
10942	auto code = compile(proc);	10948	auto code = compile(proc);
10943		10949
10944	for (auto& left : floatingPointOperands<double>()) {	10950	for (auto& left : floatingPointOperands<double>()) {
Lines 10955-10961 void testSelectDoubleCompareDouble(bool Source/JavaScriptCore/b3/testb3.cpp_sec553
10955	Value* arg1 = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);	10961	Value* arg1 = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
10956	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR2);	10962	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR2);
10957		10963
10958	root->appendNew<ControlValue>(	10964	root->appendNewControlValue(
10959	proc, Return, Origin(),	10965	proc, Return, Origin(),
10960	root->appendNew<Value>(	10966	root->appendNew<Value>(
10961	proc, Select, Origin(),	10967	proc, Select, Origin(),
Lines 10990-10996 void testSelectDoubleCompareDouble(bool Source/JavaScriptCore/b3/testb3.cpp_sec554
10990	keepValuesLive->append(ConstrainedValue(arg2, ValueRep::SomeRegister));	10996	keepValuesLive->append(ConstrainedValue(arg2, ValueRep::SomeRegister));
10991	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	10997	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
10992		10998
10993	root->appendNew<ControlValue>(proc, Return, Origin(), result);	10999	root->appendNewControlValue(proc, Return, Origin(), result);
10994	auto code = compile(proc);	11000	auto code = compile(proc);
10995		11001
10996	for (auto& left : floatingPointOperands<double>()) {	11002	for (auto& left : floatingPointOperands<double>()) {
Lines 11033-11039 void testSelectFloatCompareFloat(bool (* Source/JavaScriptCore/b3/testb3.cpp_sec555
11033	root->appendNew<Value>(proc, Trunc, Origin(),	11039	root->appendNew<Value>(proc, Trunc, Origin(),
11034	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR3)));	11040	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR3)));
11035		11041
11036	root->appendNew<ControlValue>(	11042	root->appendNewControlValue(
11037	proc, Return, Origin(),	11043	proc, Return, Origin(),
11038	root->appendNew<Value>(	11044	root->appendNew<Value>(
11039	proc, Select, Origin(),	11045	proc, Select, Origin(),
Lines 11077-11083 void testSelectFloatCompareFloat(bool (* Source/JavaScriptCore/b3/testb3.cpp_sec556
11077	keepValuesLive->append(ConstrainedValue(arg2, ValueRep::SomeRegister));	11083	keepValuesLive->append(ConstrainedValue(arg2, ValueRep::SomeRegister));
11078	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	11084	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
11079		11085
11080	root->appendNew<ControlValue>(proc, Return, Origin(), result);	11086	root->appendNewControlValue(proc, Return, Origin(), result);
11081	auto code = compile(proc);	11087	auto code = compile(proc);
11082		11088
11083	for (auto& left : floatingPointOperands<float>()) {	11089	for (auto& left : floatingPointOperands<float>()) {
Lines 11112-11118 void testSelectFloatCompareFloat(bool (* Source/JavaScriptCore/b3/testb3.cpp_sec557
11112	keepValuesLive->append(ConstrainedValue(arg3, ValueRep::SomeRegister));	11118	keepValuesLive->append(ConstrainedValue(arg3, ValueRep::SomeRegister));
11113	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	11119	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
11114		11120
11115	root->appendNew<ControlValue>(proc, Return, Origin(), result);	11121	root->appendNewControlValue(proc, Return, Origin(), result);
11116	auto code = compile(proc);	11122	auto code = compile(proc);
11117		11123
11118	for (auto& left : floatingPointOperands<float>()) {	11124	for (auto& left : floatingPointOperands<float>()) {
Lines 11148-11154 void testSelectFloatCompareFloat(bool (* Source/JavaScriptCore/b3/testb3.cpp_sec558
11148	keepValuesLive->append(ConstrainedValue(arg3, ValueRep::SomeRegister));	11154	keepValuesLive->append(ConstrainedValue(arg3, ValueRep::SomeRegister));
11149	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	11155	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
11150		11156
11151	root->appendNew<ControlValue>(proc, Return, Origin(), result);	11157	root->appendNewControlValue(proc, Return, Origin(), result);
11152	auto code = compile(proc);	11158	auto code = compile(proc);
11153		11159
11154	for (auto& left : floatingPointOperands<float>()) {	11160	for (auto& left : floatingPointOperands<float>()) {
Lines 11171-11177 void testSelectFloatCompareFloat(bool (* Source/JavaScriptCore/b3/testb3.cpp_sec559
11171	root->appendNew<Value>(proc, Trunc, Origin(),	11177	root->appendNew<Value>(proc, Trunc, Origin(),
11172	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2)));	11178	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2)));
11173		11179
11174	root->appendNew<ControlValue>(	11180	root->appendNewControlValue(
11175	proc, Return, Origin(),	11181	proc, Return, Origin(),
11176	root->appendNew<Value>(	11182	root->appendNew<Value>(
11177	proc, Select, Origin(),	11183	proc, Select, Origin(),
Lines 11212-11218 void testSelectFloatCompareFloat(bool (* Source/JavaScriptCore/b3/testb3.cpp_sec560
11212	keepValuesLive->append(ConstrainedValue(arg2, ValueRep::SomeRegister));	11218	keepValuesLive->append(ConstrainedValue(arg2, ValueRep::SomeRegister));
11213	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });	11219	keepValuesLive->setGenerator([&] (CCallHelpers&, const StackmapGenerationParams&) { });
11214		11220
11215	root->appendNew<ControlValue>(proc, Return, Origin(), result);	11221	root->appendNewControlValue(proc, Return, Origin(), result);
11216	auto code = compile(proc);	11222	auto code = compile(proc);
11217		11223
11218	for (auto& left : floatingPointOperands<float>()) {	11224	for (auto& left : floatingPointOperands<float>()) {
Lines 11239-11245 void testSelectFold(intptr_t value) Source/JavaScriptCore/b3/testb3.cpp_sec561
11239	{	11245	{
11240	Procedure proc;	11246	Procedure proc;
11241	BasicBlock* root = proc.addBlock();	11247	BasicBlock* root = proc.addBlock();
11242	root->appendNew<ControlValue>(	11248	root->appendNewControlValue(
11243	proc, Return, Origin(),	11249	proc, Return, Origin(),
11244	root->appendNew<Value>(	11250	root->appendNew<Value>(
11245	proc, Select, Origin(),	11251	proc, Select, Origin(),
Lines 11259-11265 void testSelectInvert() Source/JavaScriptCore/b3/testb3.cpp_sec562
11259	{	11265	{
11260	Procedure proc;	11266	Procedure proc;
11261	BasicBlock* root = proc.addBlock();	11267	BasicBlock* root = proc.addBlock();
11262	root->appendNew<ControlValue>(	11268	root->appendNewControlValue(
11263	proc, Return, Origin(),	11269	proc, Return, Origin(),
11264	root->appendNew<Value>(	11270	root->appendNew<Value>(
11265	proc, Select, Origin(),	11271	proc, Select, Origin(),
Lines 11312-11318 void testCheckSelect() Source/JavaScriptCore/b3/testb3.cpp_sec563
11312	jit.ret();	11318	jit.ret();
11313	});	11319	});
11314		11320
11315	root->appendNew<ControlValue>(	11321	root->appendNewControlValue(
11316	proc, Return, Origin(),	11322	proc, Return, Origin(),
11317	root->appendNew<Const32Value>(proc, Origin(), 0));	11323	root->appendNew<Const32Value>(proc, Origin(), 0));
11318		11324
Lines 11383-11389 void testCheckSelectCheckSelect() Source/JavaScriptCore/b3/testb3.cpp_sec564
11383	jit.ret();	11389	jit.ret();
11384	});	11390	});
11385		11391
11386	root->appendNew<ControlValue>(	11392	root->appendNewControlValue(
11387	proc, Return, Origin(),	11393	proc, Return, Origin(),
11388	root->appendNew<Const32Value>(proc, Origin(), 0));	11394	root->appendNew<Const32Value>(proc, Origin(), 0));
11389		11395
Lines 11419-11425 void testPowDoubleByIntegerLoop(double x Source/JavaScriptCore/b3/testb3.cpp_sec565
11419	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	11425	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
11420	auto result = powDoubleInt32(proc, root, Origin(), x, y);	11426	auto result = powDoubleInt32(proc, root, Origin(), x, y);
11421	BasicBlock* continuation = result.first;	11427	BasicBlock* continuation = result.first;
11422	continuation->appendNew<ControlValue>(proc, Return, Origin(), result.second);	11428	continuation->appendNewControlValue(proc, Return, Origin(), result.second);
11423		11429
11424	CHECK(isIdentical(compileAndRun<double>(proc, xOperand, yOperand), b3Pow(xOperand, yOperand)));	11430	CHECK(isIdentical(compileAndRun<double>(proc, xOperand, yOperand), b3Pow(xOperand, yOperand)));
11425	}	11431	}
Lines 11429-11435 void testTruncOrHigh() Source/JavaScriptCore/b3/testb3.cpp_sec566
11429	Procedure proc;	11435	Procedure proc;
11430	BasicBlock* root = proc.addBlock();	11436	BasicBlock* root = proc.addBlock();
11431		11437
11432	root->appendNew<ControlValue>(	11438	root->appendNewControlValue(
11433	proc, Return, Origin(),	11439	proc, Return, Origin(),
11434	root->appendNew<Value>(	11440	root->appendNew<Value>(
11435	proc, Trunc, Origin(),	11441	proc, Trunc, Origin(),
Lines 11447-11453 void testTruncOrLow() Source/JavaScriptCore/b3/testb3.cpp_sec567
11447	Procedure proc;	11453	Procedure proc;
11448	BasicBlock* root = proc.addBlock();	11454	BasicBlock* root = proc.addBlock();
11449		11455
11450	root->appendNew<ControlValue>(	11456	root->appendNewControlValue(
11451	proc, Return, Origin(),	11457	proc, Return, Origin(),
11452	root->appendNew<Value>(	11458	root->appendNew<Value>(
11453	proc, Trunc, Origin(),	11459	proc, Trunc, Origin(),
Lines 11465-11471 void testBitAndOrHigh() Source/JavaScriptCore/b3/testb3.cpp_sec568
11465	Procedure proc;	11471	Procedure proc;
11466	BasicBlock* root = proc.addBlock();	11472	BasicBlock* root = proc.addBlock();
11467		11473
11468	root->appendNew<ControlValue>(	11474	root->appendNewControlValue(
11469	proc, Return, Origin(),	11475	proc, Return, Origin(),
11470	root->appendNew<Value>(	11476	root->appendNew<Value>(
11471	proc, BitAnd, Origin(),	11477	proc, BitAnd, Origin(),
Lines 11484-11490 void testBitAndOrLow() Source/JavaScriptCore/b3/testb3.cpp_sec569
11484	Procedure proc;	11490	Procedure proc;
11485	BasicBlock* root = proc.addBlock();	11491	BasicBlock* root = proc.addBlock();
11486		11492
11487	root->appendNew<ControlValue>(	11493	root->appendNewControlValue(
11488	proc, Return, Origin(),	11494	proc, Return, Origin(),
11489	root->appendNew<Value>(	11495	root->appendNew<Value>(
11490	proc, BitAnd, Origin(),	11496	proc, BitAnd, Origin(),
Lines 11507-11526 void testBranch64Equal(int64_t left, int Source/JavaScriptCore/b3/testb3.cpp_sec570
11507		11513
11508	Value* arg1 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	11514	Value* arg1 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
11509	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	11515	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
11510	root->appendNew<ControlValue>(	11516	root->appendNewControlValue(
11511	proc, Branch, Origin(),	11517	proc, Branch, Origin(),
11512	root->appendNew<Value>(proc, Equal, Origin(), arg1, arg2),	11518	root->appendNew<Value>(proc, Equal, Origin(), arg1, arg2),
11513	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	11519	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
11514		11520
11515	bool trueResult = true;	11521	bool trueResult = true;
11516	thenCase->appendNew<ControlValue>(	11522	thenCase->appendNewControlValue(
11517	proc, Return, Origin(),	11523	proc, Return, Origin(),
11518	thenCase->appendNew<MemoryValue>(	11524	thenCase->appendNew<MemoryValue>(
11519	proc, Load8Z, Origin(),	11525	proc, Load8Z, Origin(),
11520	thenCase->appendNew<ConstPtrValue>(proc, Origin(), &trueResult)));	11526	thenCase->appendNew<ConstPtrValue>(proc, Origin(), &trueResult)));
11521		11527
11522	bool elseResult = false;	11528	bool elseResult = false;
11523	elseCase->appendNew<ControlValue>(	11529	elseCase->appendNewControlValue(
11524	proc, Return, Origin(),	11530	proc, Return, Origin(),
11525	elseCase->appendNew<MemoryValue>(	11531	elseCase->appendNew<MemoryValue>(
11526	proc, Load8Z, Origin(),	11532	proc, Load8Z, Origin(),
Lines 11538-11557 void testBranch64EqualImm(int64_t left, Source/JavaScriptCore/b3/testb3.cpp_sec571
11538		11544
11539	Value* arg1 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	11545	Value* arg1 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
11540	Value* arg2 = root->appendNew<ConstPtrValue>(proc, Origin(), right);	11546	Value* arg2 = root->appendNew<ConstPtrValue>(proc, Origin(), right);
11541	root->appendNew<ControlValue>(	11547	root->appendNewControlValue(
11542	proc, Branch, Origin(),	11548	proc, Branch, Origin(),
11543	root->appendNew<Value>(proc, Equal, Origin(), arg1, arg2),	11549	root->appendNew<Value>(proc, Equal, Origin(), arg1, arg2),
11544	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	11550	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
11545		11551
11546	bool trueResult = true;	11552	bool trueResult = true;
11547	thenCase->appendNew<ControlValue>(	11553	thenCase->appendNewControlValue(
11548	proc, Return, Origin(),	11554	proc, Return, Origin(),
11549	thenCase->appendNew<MemoryValue>(	11555	thenCase->appendNew<MemoryValue>(
11550	proc, Load8Z, Origin(),	11556	proc, Load8Z, Origin(),
11551	thenCase->appendNew<ConstPtrValue>(proc, Origin(), &trueResult)));	11557	thenCase->appendNew<ConstPtrValue>(proc, Origin(), &trueResult)));
11552		11558
11553	bool elseResult = false;	11559	bool elseResult = false;
11554	elseCase->appendNew<ControlValue>(	11560	elseCase->appendNewControlValue(
11555	proc, Return, Origin(),	11561	proc, Return, Origin(),
11556	elseCase->appendNew<MemoryValue>(	11562	elseCase->appendNew<MemoryValue>(
11557	proc, Load8Z, Origin(),	11563	proc, Load8Z, Origin(),
Lines 11571-11590 void testBranch64EqualMem(int64_t left, Source/JavaScriptCore/b3/testb3.cpp_sec572
11571	proc, Load, pointerType(), Origin(),	11577	proc, Load, pointerType(), Origin(),
11572	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	11578	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
11573	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	11579	Value* arg2 = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
11574	root->appendNew<ControlValue>(	11580	root->appendNewControlValue(
11575	proc, Branch, Origin(),	11581	proc, Branch, Origin(),
11576	root->appendNew<Value>(proc, Equal, Origin(), arg1, arg2),	11582	root->appendNew<Value>(proc, Equal, Origin(), arg1, arg2),
11577	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	11583	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
11578		11584
11579	bool trueResult = true;	11585	bool trueResult = true;
11580	thenCase->appendNew<ControlValue>(	11586	thenCase->appendNewControlValue(
11581	proc, Return, Origin(),	11587	proc, Return, Origin(),
11582	thenCase->appendNew<MemoryValue>(	11588	thenCase->appendNew<MemoryValue>(
11583	proc, Load8Z, Origin(),	11589	proc, Load8Z, Origin(),
11584	thenCase->appendNew<ConstPtrValue>(proc, Origin(), &trueResult)));	11590	thenCase->appendNew<ConstPtrValue>(proc, Origin(), &trueResult)));
11585		11591
11586	bool elseResult = false;	11592	bool elseResult = false;
11587	elseCase->appendNew<ControlValue>(	11593	elseCase->appendNewControlValue(
11588	proc, Return, Origin(),	11594	proc, Return, Origin(),
11589	elseCase->appendNew<MemoryValue>(	11595	elseCase->appendNew<MemoryValue>(
11590	proc, Load8Z, Origin(),	11596	proc, Load8Z, Origin(),
Lines 11604-11623 void testBranch64EqualMemImm(int64_t lef Source/JavaScriptCore/b3/testb3.cpp_sec573
11604	proc, Load, pointerType(), Origin(),	11610	proc, Load, pointerType(), Origin(),
11605	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	11611	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
11606	Value* arg2 = root->appendNew<ConstPtrValue>(proc, Origin(), right);	11612	Value* arg2 = root->appendNew<ConstPtrValue>(proc, Origin(), right);
11607	root->appendNew<ControlValue>(	11613	root->appendNewControlValue(
11608	proc, Branch, Origin(),	11614	proc, Branch, Origin(),
11609	root->appendNew<Value>(proc, Equal, Origin(), arg1, arg2),	11615	root->appendNew<Value>(proc, Equal, Origin(), arg1, arg2),
11610	FrequentedBlock(thenCase), FrequentedBlock(elseCase));	11616	FrequentedBlock(thenCase), FrequentedBlock(elseCase));
11611		11617
11612	bool trueResult = true;	11618	bool trueResult = true;
11613	thenCase->appendNew<ControlValue>(	11619	thenCase->appendNewControlValue(
11614	proc, Return, Origin(),	11620	proc, Return, Origin(),
11615	thenCase->appendNew<MemoryValue>(	11621	thenCase->appendNew<MemoryValue>(
11616	proc, Load8Z, Origin(),	11622	proc, Load8Z, Origin(),
11617	thenCase->appendNew<ConstPtrValue>(proc, Origin(), &trueResult)));	11623	thenCase->appendNew<ConstPtrValue>(proc, Origin(), &trueResult)));
11618		11624
11619	bool elseResult = false;	11625	bool elseResult = false;
11620	elseCase->appendNew<ControlValue>(	11626	elseCase->appendNewControlValue(
11621	proc, Return, Origin(),	11627	proc, Return, Origin(),
11622	elseCase->appendNew<MemoryValue>(	11628	elseCase->appendNew<MemoryValue>(
11623	proc, Load8Z, Origin(),	11629	proc, Load8Z, Origin(),
Lines 11641-11647 void testStore8Load8Z(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec574
11641	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	11647	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
11642	ptr);	11648	ptr);
11643		11649
11644	root->appendNew<ControlValue>(	11650	root->appendNewControlValue(
11645	proc, Return, Origin(),	11651	proc, Return, Origin(),
11646	root->appendNew<MemoryValue>(proc, Load8Z, Origin(), ptr));	11652	root->appendNew<MemoryValue>(proc, Load8Z, Origin(), ptr));
11647		11653
Lines 11663-11669 void testStore16Load16Z(int32_t value) Source/JavaScriptCore/b3/testb3.cpp_sec575
11663	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),	11669	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)),
11664	ptr);	11670	ptr);
11665		11671
11666	root->appendNew<ControlValue>(	11672	root->appendNewControlValue(
11667	proc, Return, Origin(),	11673	proc, Return, Origin(),
11668	root->appendNew<MemoryValue>(proc, Load16Z, Origin(), ptr));	11674	root->appendNew<MemoryValue>(proc, Load16Z, Origin(), ptr));
11669		11675
Lines 11675-11681 void testSShrShl32(int32_t value, int32_ Source/JavaScriptCore/b3/testb3.cpp_sec576
11675	Procedure proc;	11681	Procedure proc;
11676	BasicBlock* root = proc.addBlock();	11682	BasicBlock* root = proc.addBlock();
11677		11683
11678	root->appendNew<ControlValue>(	11684	root->appendNewControlValue(
11679	proc, Return, Origin(),	11685	proc, Return, Origin(),
11680	root->appendNew<Value>(	11686	root->appendNew<Value>(
11681	proc, SShr, Origin(),	11687	proc, SShr, Origin(),
Lines 11697-11703 void testSShrShl64(int64_t value, int32_ Source/JavaScriptCore/b3/testb3.cpp_sec577
11697	Procedure proc;	11703	Procedure proc;
11698	BasicBlock* root = proc.addBlock();	11704	BasicBlock* root = proc.addBlock();
11699		11705
11700	root->appendNew<ControlValue>(	11706	root->appendNewControlValue(
11701	proc, Return, Origin(),	11707	proc, Return, Origin(),
11702	root->appendNew<Value>(	11708	root->appendNew<Value>(
11703	proc, SShr, Origin(),	11709	proc, SShr, Origin(),
Lines 11725-11732 void testTrivialInfiniteLoop() Source/JavaScriptCore/b3/testb3.cpp_sec578
11725	Procedure proc;	11731	Procedure proc;
11726	BasicBlock* root = proc.addBlock();	11732	BasicBlock* root = proc.addBlock();
11727	BasicBlock* loop = proc.addBlock();	11733	BasicBlock* loop = proc.addBlock();
11728	root->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(loop));	11734	root->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(loop));
11729	loop->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(loop));	11735	loop->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(loop));
11730		11736
11731	compile(proc);	11737	compile(proc);
11732	}	11738	}
Lines 11740-11754 void testFoldPathEqual() Source/JavaScriptCore/b3/testb3.cpp_sec579
11740		11746
11741	Value* arg = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	11747	Value* arg = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
11742		11748
11743	root->appendNew<ControlValue>(	11749	root->appendNewControlValue(
11744	proc, Branch, Origin(), arg, FrequentedBlock(thenBlock), FrequentedBlock(elseBlock));	11750	proc, Branch, Origin(), arg, FrequentedBlock(thenBlock), FrequentedBlock(elseBlock));
11745		11751
11746	thenBlock->appendNew<ControlValue>(	11752	thenBlock->appendNewControlValue(
11747	proc, Return, Origin(),	11753	proc, Return, Origin(),
11748	thenBlock->appendNew<Value>(	11754	thenBlock->appendNew<Value>(
11749	proc, Equal, Origin(), arg, thenBlock->appendNew<ConstPtrValue>(proc, Origin(), 0)));	11755	proc, Equal, Origin(), arg, thenBlock->appendNew<ConstPtrValue>(proc, Origin(), 0)));
11750		11756
11751	elseBlock->appendNew<ControlValue>(	11757	elseBlock->appendNewControlValue(
11752	proc, Return, Origin(),	11758	proc, Return, Origin(),
11753	elseBlock->appendNew<Value>(	11759	elseBlock->appendNew<Value>(
11754	proc, Equal, Origin(), arg, elseBlock->appendNew<ConstPtrValue>(proc, Origin(), 0)));	11760	proc, Equal, Origin(), arg, elseBlock->appendNew<ConstPtrValue>(proc, Origin(), 0)));
Lines 11766-11772 void testLShiftSelf32() Source/JavaScriptCore/b3/testb3.cpp_sec580
11766	Value* arg = root->appendNew<Value>(	11772	Value* arg = root->appendNew<Value>(
11767	proc, Trunc, Origin(),	11773	proc, Trunc, Origin(),
11768	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	11774	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
11769	root->appendNew<ControlValue>(	11775	root->appendNewControlValue(
11770	proc, Return, Origin(),	11776	proc, Return, Origin(),
11771	root->appendNew<Value>(proc, Shl, Origin(), arg, arg));	11777	root->appendNew<Value>(proc, Shl, Origin(), arg, arg));
11772		11778
Lines 11789-11795 void testRShiftSelf32() Source/JavaScriptCore/b3/testb3.cpp_sec581
11789	Value* arg = root->appendNew<Value>(	11795	Value* arg = root->appendNew<Value>(
11790	proc, Trunc, Origin(),	11796	proc, Trunc, Origin(),
11791	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	11797	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
11792	root->appendNew<ControlValue>(	11798	root->appendNewControlValue(
11793	proc, Return, Origin(),	11799	proc, Return, Origin(),
11794	root->appendNew<Value>(proc, SShr, Origin(), arg, arg));	11800	root->appendNew<Value>(proc, SShr, Origin(), arg, arg));
11795		11801
Lines 11812-11818 void testURShiftSelf32() Source/JavaScriptCore/b3/testb3.cpp_sec582
11812	Value* arg = root->appendNew<Value>(	11818	Value* arg = root->appendNew<Value>(
11813	proc, Trunc, Origin(),	11819	proc, Trunc, Origin(),
11814	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));	11820	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
11815	root->appendNew<ControlValue>(	11821	root->appendNewControlValue(
11816	proc, Return, Origin(),	11822	proc, Return, Origin(),
11817	root->appendNew<Value>(proc, ZShr, Origin(), arg, arg));	11823	root->appendNew<Value>(proc, ZShr, Origin(), arg, arg));
11818		11824
Lines 11833-11839 void testLShiftSelf64() Source/JavaScriptCore/b3/testb3.cpp_sec583
11833	Procedure proc;	11839	Procedure proc;
11834	BasicBlock* root = proc.addBlock();	11840	BasicBlock* root = proc.addBlock();
11835	Value* arg = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	11841	Value* arg = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
11836	root->appendNew<ControlValue>(	11842	root->appendNewControlValue(
11837	proc, Return, Origin(),	11843	proc, Return, Origin(),
11838	root->appendNew<Value>(	11844	root->appendNew<Value>(
11839	proc, Shl, Origin(), arg, root->appendNew<Value>(proc, Trunc, Origin(), arg)));	11845	proc, Shl, Origin(), arg, root->appendNew<Value>(proc, Trunc, Origin(), arg)));
Lines 11857-11863 void testRShiftSelf64() Source/JavaScriptCore/b3/testb3.cpp_sec584
11857	Procedure proc;	11863	Procedure proc;
11858	BasicBlock* root = proc.addBlock();	11864	BasicBlock* root = proc.addBlock();
11859	Value* arg = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	11865	Value* arg = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
11860	root->appendNew<ControlValue>(	11866	root->appendNewControlValue(
11861	proc, Return, Origin(),	11867	proc, Return, Origin(),
11862	root->appendNew<Value>(	11868	root->appendNew<Value>(
11863	proc, SShr, Origin(), arg, root->appendNew<Value>(proc, Trunc, Origin(), arg)));	11869	proc, SShr, Origin(), arg, root->appendNew<Value>(proc, Trunc, Origin(), arg)));
Lines 11881-11887 void testURShiftSelf64() Source/JavaScriptCore/b3/testb3.cpp_sec585
11881	Procedure proc;	11887	Procedure proc;
11882	BasicBlock* root = proc.addBlock();	11888	BasicBlock* root = proc.addBlock();
11883	Value* arg = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	11889	Value* arg = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
11884	root->appendNew<ControlValue>(	11890	root->appendNewControlValue(
11885	proc, Return, Origin(),	11891	proc, Return, Origin(),
11886	root->appendNew<Value>(	11892	root->appendNew<Value>(
11887	proc, ZShr, Origin(), arg, root->appendNew<Value>(proc, Trunc, Origin(), arg)));	11893	proc, ZShr, Origin(), arg, root->appendNew<Value>(proc, Trunc, Origin(), arg)));
Lines 11917-11923 void testPatchpointDoubleRegs() Source/JavaScriptCore/b3/testb3.cpp_sec586
11917	numCalls++;	11923	numCalls++;
11918	});	11924	});
11919		11925
11920	root->appendNew<ControlValue>(proc, Return, Origin(), patchpoint);	11926	root->appendNewControlValue(proc, Return, Origin(), patchpoint);
11921		11927
11922	auto code = compile(proc);	11928	auto code = compile(proc);
11923	CHECK(numCalls == 1);	11929	CHECK(numCalls == 1);
Lines 11950-11956 void testSpillDefSmallerThanUse() Source/JavaScriptCore/b3/testb3.cpp_sec587
11950		11956
11951	// On x86, Sub admit an address for any operand. If it uses the stack, the top bits must be zero.	11957	// On x86, Sub admit an address for any operand. If it uses the stack, the top bits must be zero.
11952	Value* result = root->appendNew<Value>(proc, Sub, Origin(), forceSpill, arg64);	11958	Value* result = root->appendNew<Value>(proc, Sub, Origin(), forceSpill, arg64);
11953	root->appendNew<ControlValue>(proc, Return, Origin(), result);	11959	root->appendNewControlValue(proc, Return, Origin(), result);
11954		11960
11955	auto code = compile(proc);	11961	auto code = compile(proc);
11956	CHECK(invoke<int64_t>(*code, 0xffffffff00000000) == 0);	11962	CHECK(invoke<int64_t>(*code, 0xffffffff00000000) == 0);
Lines 11970-11976 void testSpillUseLargerThanDef() Source/JavaScriptCore/b3/testb3.cpp_sec588
11970		11976
11971	Value* condition = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	11977	Value* condition = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
11972	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);	11978	Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
11973	root->appendNew<ControlValue>(	11979	root->appendNewControlValue(
11974	proc, Branch, Origin(),	11980	proc, Branch, Origin(),
11975	root->appendNew<Value>(	11981	root->appendNew<Value>(
11976	proc, Trunc, Origin(),	11982	proc, Trunc, Origin(),
Lines 11980-11989 void testSpillUseLargerThanDef() Source/JavaScriptCore/b3/testb3.cpp_sec589
11980	Value* truncated = thenCase->appendNew<Value>(proc, ZExt32, Origin(),	11986	Value* truncated = thenCase->appendNew<Value>(proc, ZExt32, Origin(),
11981	thenCase->appendNew<Value>(proc, Trunc, Origin(), argument));	11987	thenCase->appendNew<Value>(proc, Trunc, Origin(), argument));
11982	UpsilonValue* thenResult = thenCase->appendNew<UpsilonValue>(proc, Origin(), truncated);	11988	UpsilonValue* thenResult = thenCase->appendNew<UpsilonValue>(proc, Origin(), truncated);
11983	thenCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	11989	thenCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
11984		11990
11985	UpsilonValue* elseResult = elseCase->appendNew<UpsilonValue>(proc, Origin(), argument);	11991	UpsilonValue* elseResult = elseCase->appendNew<UpsilonValue>(proc, Origin(), argument);
11986	elseCase->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(tail));	11992	elseCase->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(tail));
11987		11993
11988	for (unsigned i = 0; i < 100; ++i) {	11994	for (unsigned i = 0; i < 100; ++i) {
11989	PatchpointValue* preventTailDuplication = tail->appendNew<PatchpointValue>(proc, Void, Origin());	11995	PatchpointValue* preventTailDuplication = tail->appendNew<PatchpointValue>(proc, Void, Origin());
Lines 12004-12010 void testSpillUseLargerThanDef() Source/JavaScriptCore/b3/testb3.cpp_sec590
12004	Value* phi = tail->appendNew<Value>(proc, Phi, Int64, Origin());	12010	Value* phi = tail->appendNew<Value>(proc, Phi, Int64, Origin());
12005	thenResult->setPhi(phi);	12011	thenResult->setPhi(phi);
12006	elseResult->setPhi(phi);	12012	elseResult->setPhi(phi);
12007	tail->appendNew<ControlValue>(proc, Return, Origin(), phi);	12013	tail->appendNewControlValue(proc, Return, Origin(), phi);
12008		12014
12009	auto code = compile(proc);	12015	auto code = compile(proc);
12010	CHECK(invoke<uint64_t>(*code, 1, 0xffffffff00000000) == 0);	12016	CHECK(invoke<uint64_t>(*code, 1, 0xffffffff00000000) == 0);
Lines 12086-12097 void testLateRegister() Source/JavaScriptCore/b3/testb3.cpp_sec591
12086	jit.nop();	12092	jit.nop();
12087	jit.nop();	12093	jit.nop();
12088	});	12094	});
12089	root->appendNew<ControlValue>(proc, Return, Origin(), secondPatchpoint);	12095	root->appendNewControlValue(proc, Return, Origin(), secondPatchpoint);
12090		12096
12091	auto code = compile(proc);	12097	auto code = compile(proc);
12092	CHECK(invoke<uint64_t>(*code) == result);	12098	CHECK(invoke<uint64_t>(*code) == result);
12093	}	12099	}
12094		12100
		12101	void threadedInterpreterPrint(Vector<intptr_t>* stream, intptr_t value)
		12102	{
		12103	stream->append(value);
		12104	}
		12105
		12106	void testThreadedInterpreter()
		12107	{
		12108	// This creates a poor man's threaded interpreter using PolyJump and sees if it works. Note
		12109	// that PolyJump is not like indirect branches in LLVM, so you can't actually use it to
		12110	// implement a proper threaded interpreter. This cheats: the dispatch instruction is at the top
		12111	// of the loop. This also tests VariableValue.
		12112
		12113	Procedure proc;
		12114
		12115	BasicBlock* root = proc.addBlock();
		12116	BasicBlock* dispatch = proc.addBlock();
		12117	BasicBlock* addToDataPointer = proc.addBlock();
		12118	BasicBlock* addToCodePointer = proc.addBlock();
		12119	BasicBlock* addToCodePointerTaken = proc.addBlock();
		12120	BasicBlock* addToCodePointerNotTaken = proc.addBlock();
		12121	BasicBlock* addToData = proc.addBlock();
		12122	BasicBlock* print = proc.addBlock();
		12123	BasicBlock* stop = proc.addBlock();
		12124
		12125	Variable* dataPointer = proc.addVariable(pointerType());
		12126	Variable* codePointer = proc.addVariable(pointerType());
		12127
		12128	root->appendNew<VariableValue>(
		12129	proc, Set, Origin(), dataPointer,
		12130	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
		12131	root->appendNew<VariableValue>(
		12132	proc, Set, Origin(), codePointer,
		12133	root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
		12134	Value* context = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2);
		12135	root->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(dispatch));
		12136
		12137	Value* codePointerValue =
		12138	dispatch->appendNew<VariableValue>(proc, B3::Get, Origin(), codePointer);
		12139	PatchpointValue* polyJump = dispatch->appendNew<PatchpointValue>(proc, Void, Origin());
		12140	polyJump->effects.terminal = true;
		12141	polyJump->appendSomeRegister(codePointerValue);
		12142	dispatch->appendSuccessor(FrequentedBlock(addToDataPointer));
		12143	dispatch->appendSuccessor(FrequentedBlock(addToCodePointer));
		12144	dispatch->appendSuccessor(FrequentedBlock(addToData));
		12145	dispatch->appendSuccessor(FrequentedBlock(print));
		12146	dispatch->appendSuccessor(FrequentedBlock(stop));
		12147
		12148	// Our "opcodes". They will have meaning once we compile.
		12149	intptr_t AddDP = 0;
		12150	intptr_t AddCP = 0;
		12151	intptr_t Add = 0;
		12152	intptr_t Print = 0;
		12153	intptr_t Stop = 0;
		12154	polyJump->setGenerator(
		12155	[&] (CCallHelpers& jit, const StackmapGenerationParams& params) {
		12156	jit.jump(CCallHelpers::Address(params[0].gpr()));
		12157
		12158	Vector<Box<CCallHelpers::Label>> labels = params.successorLabels();
		12159
		12160	jit.addLinkTask(
		12161	[&, labels] (LinkBuffer& linkBuffer) {
		12162	auto get = [&] (size_t index) -> intptr_t {
		12163	return bitwise_cast<intptr_t>(
		12164	linkBuffer.locationOf(*labels[index]).executableAddress());
12165	};
12166
12167	AddDP = get(0);
12168	AddCP = get(1);
12169	Add = get(2);
12170	Print = get(3);
12171	Stop = get(4);
12172	});
12173	});
12174
12175	// AddDP <operand>: adds <operand> to DP.
12176	codePointerValue =
12177	addToDataPointer->appendNew<VariableValue>(proc, B3::Get, Origin(), codePointer);
12178	addToDataPointer->appendNew<VariableValue>(
12179	proc, Set, Origin(), dataPointer,
12180	addToDataPointer->appendNew<Value>(
12181	proc, B3::Add, Origin(),
12182	addToDataPointer->appendNew<VariableValue>(proc, B3::Get, Origin(), dataPointer),
12183	addToDataPointer->appendNew<Value>(
12184	proc, Mul, Origin(),
12185	addToDataPointer->appendNew<MemoryValue>(
12186	proc, Load, pointerType(), Origin(), codePointerValue, sizeof(intptr_t)),
12187	addToDataPointer->appendIntConstant(
12188	proc, Origin(), pointerType(), sizeof(intptr_t)))));
12189	addToDataPointer->appendNew<VariableValue>(
12190	proc, Set, Origin(), codePointer,
12191	addToDataPointer->appendNew<Value>(
12192	proc, B3::Add, Origin(), codePointerValue,
12193	addToDataPointer->appendIntConstant(
12194	proc, Origin(), pointerType(), sizeof(intptr_t) * 2)));
12195	addToDataPointer->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(dispatch));
12196
12197	// AddCP <operand>: adds <operand> to CP if the current value at DP is non-zero, otherwise
12198	// falls through normally.
12199	codePointerValue =
12200	addToCodePointer->appendNew<VariableValue>(proc, B3::Get, Origin(), codePointer);
12201	Value* dataPointerValue =
12202	addToCodePointer->appendNew<VariableValue>(proc, B3::Get, Origin(), dataPointer);
12203	addToCodePointer->appendNewControlValue(
12204	proc, Branch, Origin(),
12205	addToCodePointer->appendNew<MemoryValue>(
12206	proc, Load, pointerType(), Origin(), dataPointerValue),
12207	FrequentedBlock(addToCodePointerTaken), FrequentedBlock(addToCodePointerNotTaken));
12208	addToCodePointerTaken->appendNew<VariableValue>(
12209	proc, Set, Origin(), codePointer,
12210	addToCodePointerTaken->appendNew<Value>(
12211	proc, B3::Add, Origin(), codePointerValue,
12212	addToCodePointerTaken->appendNew<Value>(
12213	proc, Mul, Origin(),
12214	addToCodePointerTaken->appendNew<MemoryValue>(
12215	proc, Load, pointerType(), Origin(), codePointerValue, sizeof(intptr_t)),
12216	addToCodePointerTaken->appendIntConstant(
12217	proc, Origin(), pointerType(), sizeof(intptr_t)))));
12218	addToCodePointerTaken->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(dispatch));
12219	addToCodePointerNotTaken->appendNew<VariableValue>(
12220	proc, Set, Origin(), codePointer,
12221	addToCodePointerNotTaken->appendNew<Value>(
12222	proc, B3::Add, Origin(), codePointerValue,
12223	addToCodePointerNotTaken->appendIntConstant(
12224	proc, Origin(), pointerType(), sizeof(intptr_t) * 2)));
12225	addToCodePointerNotTaken->appendNewControlValue(
12226	proc, Jump, Origin(), FrequentedBlock(dispatch));
12227
12228	// Add <operand>: adds <operand> to the slot pointed to by DP.
12229	codePointerValue = addToData->appendNew<VariableValue>(proc, B3::Get, Origin(), codePointer);
12230	dataPointerValue = addToData->appendNew<VariableValue>(proc, B3::Get, Origin(), dataPointer);
12231	addToData->appendNew<MemoryValue>(
12232	proc, Store, Origin(),
12233	addToData->appendNew<Value>(
12234	proc, B3::Add, Origin(),
12235	addToData->appendNew<MemoryValue>(
12236	proc, Load, pointerType(), Origin(), dataPointerValue),
12237	addToData->appendNew<MemoryValue>(
12238	proc, Load, pointerType(), Origin(), codePointerValue, sizeof(intptr_t))),
12239	dataPointerValue);
12240	addToData->appendNew<VariableValue>(
12241	proc, Set, Origin(), codePointer,
12242	addToData->appendNew<Value>(
12243	proc, B3::Add, Origin(), codePointerValue,
12244	addToData->appendIntConstant(proc, Origin(), pointerType(), sizeof(intptr_t) * 2)));
12245	addToData->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(dispatch));
12246
12247	// Print: "prints" the value pointed to by DP. What this actually means is that the value is
12248	// appended to the stream vector by the threadedInterpreterPrint function.
12249	codePointerValue = print->appendNew<VariableValue>(proc, B3::Get, Origin(), codePointer);
12250	dataPointerValue = print->appendNew<VariableValue>(proc, B3::Get, Origin(), dataPointer);
12251	print->appendNew<CCallValue>(
12252	proc, Void, Origin(),
12253	print->appendNew<ConstPtrValue>(
12254	proc, Origin(), bitwise_cast<void*>(threadedInterpreterPrint)),
12255	context,
12256	print->appendNew<MemoryValue>(proc, Load, pointerType(), Origin(), dataPointerValue));
12257	print->appendNew<VariableValue>(
12258	proc, Set, Origin(), codePointer,
12259	print->appendNew<Value>(
12260	proc, B3::Add, Origin(), codePointerValue,
12261	print->appendIntConstant(proc, Origin(), pointerType(), sizeof(intptr_t))));
12262	print->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(dispatch));
12263
12264	// Stop: returns.
12265	stop->appendNewControlValue(
12266	proc, Return, Origin(),
12267	stop->appendIntConstant(proc, Origin(), pointerType(), 0));
12268
12269	auto interpreter = compile(proc);
12270
12271	CHECK(AddDP);
12272	CHECK(AddCP);
12273	CHECK(Add);
12274	CHECK(Print);
12275	CHECK(Stop);
12276
12277	Vector<intptr_t> data;
12278	Vector<intptr_t> code;
12279	Vector<intptr_t> stream;
12280
12281	data.append(1);
12282	data.append(0);
12283
12284	if (shouldBeVerbose())
12285	dataLog("data = ", listDump(data), "\n");
12286
12287	// We'll write a program that prints the numbers 1..100.
12288	// We expect DP to point at #0.
12289	code.append(AddCP);
12290	code.append(6); // go to loop body
12291
12292	// Loop re-entry:
12293	// We expect DP to point at #1 and for #1 to be offset by -100.
12294	code.append(Add);
12295	code.append(100);
12296
12297	code.append(AddDP);
12298	code.append(-1);
12299
12300	// Loop header:
12301	// We expect DP to point at #0.
12302	code.append(AddDP);
12303	code.append(1);
12304
12305	code.append(Add);
12306	code.append(1);
12307
12308	code.append(Print);
12309
12310	code.append(Add);
12311	code.append(-100);
12312
12313	// We want to stop if it's zero and continue if it's non-zero. AddCP takes the branch if it's
12314	// non-zero.
12315	code.append(AddCP);
12316	code.append(-11); // go to loop re-entry.
12317
12318	code.append(Stop);
12319
12320	if (shouldBeVerbose())
12321	dataLog("code = ", listDump(code), "\n");
12322
12323	CHECK(!invoke<intptr_t>(*interpreter, data.data(), code.data(), &stream));
12324
12325	CHECK(stream.size() == 100);
12326	for (unsigned i = 0; i < 100; ++i)
12327	CHECK(stream[i] == i + 1);
12328
12329	if (shouldBeVerbose())
12330	dataLog("stream = ", listDump(stream), "\n");
12331	}
12332
12095	void testReduceStrengthCheckBottomUseInAnotherBlock()	12333	void testReduceStrengthCheckBottomUseInAnotherBlock()
12096	{	12334	{
12097	Procedure proc;	12335	Procedure proc;
Lines 12110-12116 void testReduceStrengthCheckBottomUseInA Source/JavaScriptCore/b3/testb3.cpp_sec592
12110	jit.ret();	12348	jit.ret();
12111	});	12349	});
12112	Value* arg = one->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);	12350	Value* arg = one->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
12113	one->appendNew<ControlValue>(proc, Jump, Origin(), FrequentedBlock(two));	12351	one->appendNewControlValue(proc, Jump, Origin(), FrequentedBlock(two));
12114		12352
12115	check = two->appendNew<CheckValue>(	12353	check = two->appendNew<CheckValue>(
12116	proc, CheckAdd, Origin(), arg,	12354	proc, CheckAdd, Origin(), arg,
Lines 12119-12125 void testReduceStrengthCheckBottomUseInA Source/JavaScriptCore/b3/testb3.cpp_sec593
12119	[&] (CCallHelpers&, const StackmapGenerationParams&) {	12357	[&] (CCallHelpers&, const StackmapGenerationParams&) {
12120	CHECK(!"Should not execute");	12358	CHECK(!"Should not execute");
12121	});	12359	});
12122	two->appendNew<ControlValue>(proc, Return, Origin(), check);	12360	two->appendNewControlValue(proc, Return, Origin(), check);
12123		12361
12124	proc.resetReachability();	12362	proc.resetReachability();
12125	reduceStrength(proc);	12363	reduceStrength(proc);
Lines 12134-12144 void testResetReachabilityDanglingRefere Source/JavaScriptCore/b3/testb3.cpp_sec594
12134		12372
12135	UpsilonValue* upsilon = one->appendNew<UpsilonValue>(	12373	UpsilonValue* upsilon = one->appendNew<UpsilonValue>(
12136	proc, Origin(), one->appendNew<Const32Value>(proc, Origin(), 42));	12374	proc, Origin(), one->appendNew<Const32Value>(proc, Origin(), 42));
12137	one->appendNew<ControlValue>(proc, Oops, Origin());	12375	one->appendNewControlValue(proc, Oops, Origin());
12138		12376
12139	Value* phi = two->appendNew<Value>(proc, Phi, Int32, Origin());	12377	Value* phi = two->appendNew<Value>(proc, Phi, Int32, Origin());
12140	upsilon->setPhi(phi);	12378	upsilon->setPhi(phi);
12141	two->appendNew<ControlValue>(proc, Oops, Origin());	12379	two->appendNewControlValue(proc, Oops, Origin());
12142		12380
12143	proc.resetReachability();	12381	proc.resetReachability();
12144	validate(proc);	12382	validate(proc);
Lines 13547-13552 void run(const char* filter) Source/JavaScriptCore/b3/testb3.cpp_sec595
13547	RUN(testSpillDefSmallerThanUse());	13785	RUN(testSpillDefSmallerThanUse());
13548	RUN(testSpillUseLargerThanDef());	13786	RUN(testSpillUseLargerThanDef());
13549	RUN(testLateRegister());	13787	RUN(testLateRegister());
		13788	RUN(testThreadedInterpreter());
13550	RUN(testReduceStrengthCheckBottomUseInAnotherBlock());	13789	RUN(testReduceStrengthCheckBottomUseInAnotherBlock());
13551	RUN(testResetReachabilityDanglingReference());	13790	RUN(testResetReachabilityDanglingReference());
13552		13791

Lines 30-35 Source/JavaScriptCore/b3/air/AirCode.cpp_sec1
- Source/JavaScriptCore/b3/air/AirCode.cpp +6 lines
30		30
31	#include "AirCCallSpecial.h"	31	#include "AirCCallSpecial.h"
32	#include "B3BasicBlockUtils.h"	32	#include "B3BasicBlockUtils.h"
		33	#include "B3Procedure.h"
33	#include "B3StackSlot.h"	34	#include "B3StackSlot.h"
34		35
35	namespace JSC { namespace B3 { namespace Air {	36	namespace JSC { namespace B3 { namespace Air {
Lines 135-140 void Code::addFastTmp(Tmp tmp) Source/JavaScriptCore/b3/air/AirCode.cpp_sec2
135	m_fastTmps.add(tmp);	136	m_fastTmps.add(tmp);
136	}	137	}
137		138
		139	void* Code::addDataSection(size_t size)
		140	{
		141	return m_proc.addDataSection(size);
		142	}
		143
138	unsigned Code::jsHash() const	144	unsigned Code::jsHash() const
139	{	145	{
140	unsigned result = 0;	146	unsigned result = 0;

Lines 33-38 Source/JavaScriptCore/b3/air/AirCode.h_sec1
- Source/JavaScriptCore/b3/air/AirCode.h +3 lines
33	#include "AirSpecial.h"	33	#include "AirSpecial.h"
34	#include "AirStackSlot.h"	34	#include "AirStackSlot.h"
35	#include "AirTmp.h"	35	#include "AirTmp.h"
		36	#include "B3IndexMap.h"
36	#include "B3SparseCollection.h"	37	#include "B3SparseCollection.h"
37	#include "RegisterAtOffsetList.h"	38	#include "RegisterAtOffsetList.h"
38	#include "StackAlignment.h"	39	#include "StackAlignment.h"
Lines 203-208 public: Source/JavaScriptCore/b3/air/AirCode.h_sec2
203	void addFastTmp(Tmp);	204	void addFastTmp(Tmp);
204	bool isFastTmp(Tmp tmp) const { return m_fastTmps.contains(tmp); }	205	bool isFastTmp(Tmp tmp) const { return m_fastTmps.contains(tmp); }
205		206
		207	void* addDataSection(size_t);
		208
206	// The name has to be a string literal, since we don't do any memory management for the string.	209	// The name has to be a string literal, since we don't do any memory management for the string.
207	void setLastPhaseName(const char* name)	210	void setLastPhaseName(const char* name)
208	{	211	{

Lines 84-93 struct PatchCustom { Source/JavaScriptCore/b3/air/AirCustom.h_sec1
- Source/JavaScriptCore/b3/air/AirCustom.h -1 / +16 lines
84	{	84	{
85	return inst.args[0].special()->shouldTryAliasingDef(inst);	85	return inst.args[0].special()->shouldTryAliasingDef(inst);
86	}	86	}
		87
		88	static bool isTerminal(Inst& inst)
		89	{
		90	return inst.args[0].special()->isTerminal(inst);
		91	}
87		92
88	static bool hasNonArgNonControlEffects(Inst& inst)	93	static bool hasNonArgNonControlEffects(Inst& inst)
89	{	94	{
90	return inst.args[0].special()->hasNonArgNonControlEffects();	95	return inst.args[0].special()->hasNonArgNonControlEffects(inst);
91	}	96	}
92		97
93	static CCallHelpers::Jump generate(	98	static CCallHelpers::Jump generate(
Lines 138-143 struct CCallCustom { Source/JavaScriptCore/b3/air/AirCustom.h_sec2
138	{	143	{
139	return true;	144	return true;
140	}	145	}
		146
		147	static bool isTerminal(Inst&)
		148	{
		149	return false;
		150	}
141		151
142	static bool hasNonArgNonControlEffects(Inst&)	152	static bool hasNonArgNonControlEffects(Inst&)
143	{	153	{
Lines 197-202 struct ShuffleCustom { Source/JavaScriptCore/b3/air/AirCustom.h_sec3
197	}	207	}
198	}	208	}
199		209
		210	static bool isTerminal(Inst&)
		211	{
		212	return false;
		213	}
		214
200	static bool hasNonArgNonControlEffects(Inst&)	215	static bool hasNonArgNonControlEffects(Inst&)
201	{	216	{
202	return false;	217	return false;



#include "B3IndexMap.h"
#include "B3Procedure.h"
#include "B3TimingScope.h"
#include "B3ValueInlines.h"
#include "CCallHelpers.h"
#include "DisallowMacroScratchRegisterUsage.h"
#include "LinkBuffer.h"

namespace JSC { namespace B3 { namespace Air {



    GenerationContext context;
    context.code = &code;
    context.blockLabels.resize(code.size());
    for (BasicBlock* block : code) {
        if (block)
            context.blockLabels[block] = Box<CCallHelpers::Label>::create();
    }
    IndexMap<BasicBlock, CCallHelpers::JumpList> blockJumps(code.size());

    auto link = [&] (CCallHelpers::Jump jump, BasicBlock* target) {
        if (context.blockLabels[target]->isSet()) {
            jump.linkTo(*context.blockLabels[target], &jit);
            return;
        }


    };

    for (BasicBlock* block : code) {
        context.currentBlock = block;
        context.indexInBlock = UINT_MAX;
        blockJumps[block].link(&jit);
        CCallHelpers::Label label = jit.label();
        *context.blockLabels[block] = label;
        ASSERT(block->size() >= 1);
        for (unsigned i = 0; i < block->size() - 1; ++i) {
            context.indexInBlock = i;
            Inst& inst = block->at(i);
            addItem(inst);
            CCallHelpers::Jump jump = inst.generate(jit, context);
            ASSERT_UNUSED(jump, !jump.isSet());
        }

        context.indexInBlock = block->size() - 1;
        
        if (block->last().opcode == Jump
            && block->successorBlock(0) == code.findNextBlock(block))
            continue;

            addItem(block->last());
            continue;
        }
        
        CCallHelpers::Jump jump = block->last().generate(jit, context);
        // The jump won't be set for patchpoints. It won't be set for Oops because then it won't have
        // any successors.
        if (jump.isSet()) {
            switch (block->numSuccessors()) {
            case 1:
                link(jump, block->successorBlock(0));
                break;
            case 2:
                link(jump, block->successorBlock(0));
                if (block->successorBlock(1) != code.findNextBlock(block))
                    link(jit.jump(), block->successorBlock(1));
                break;
            default:
                RELEASE_ASSERT_NOT_REACHED();
                break;
            }
        }
        addItem(block->last());
    }
    
    context.currentBlock = nullptr;
    context.indexInBlock = UINT_MAX;

    pcToOriginMap.appendItem(jit.label(), Origin());
    // FIXME: Make late paths have Origins: https://bugs.webkit.org/show_bug.cgi?id=153689



/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions


#if ENABLE(B3_JIT)

#include "AirBasicBlock.h"
#include "B3IndexMap.h"
#include "CCallHelpers.h"
#include <wtf/Box.h>
#include <wtf/SharedTask.h>
#include <wtf/Vector.h>

namespace JSC { namespace B3 { namespace Air {

class CCallHelpers;

namespace B3 { namespace Air {

class Code;


    typedef SharedTask<LatePathFunction> LatePath;

    Vector<RefPtr<LatePath>> latePaths;
    IndexMap<BasicBlock, Box<CCallHelpers::Label>> blockLabels;
    BasicBlock* currentBlock { nullptr };
    unsigned indexInBlock { UINT_MAX };
    Code* code { nullptr };
};

} } } // namespace JSC::B3::Air

Lines 163-168 public: Source/JavaScriptCore/b3/air/AirInst.h_sec1
- Source/JavaScriptCore/b3/air/AirInst.h +6 lines
163	// This function is auto-generated by opcode_generator.rb.	163	// This function is auto-generated by opcode_generator.rb.
164	bool admitsStack(unsigned argIndex);	164	bool admitsStack(unsigned argIndex);
165	bool admitsStack(Arg&);	165	bool admitsStack(Arg&);
		166
		167	// Defined by opcode_generator.rb.
		168	bool isTerminal();
166		169
167	// Returns true if this instruction can have any effects other than control flow or arguments.	170	// Returns true if this instruction can have any effects other than control flow or arguments.
168	bool hasNonArgNonControlEffects();	171	bool hasNonArgNonControlEffects();
Lines 174-179 public: Source/JavaScriptCore/b3/air/AirInst.h_sec2
174		177
175	// Tells you if this operation has arg effects.	178	// Tells you if this operation has arg effects.
176	bool hasArgEffects();	179	bool hasArgEffects();
		180
		181	// Tells you if this operation has non-control effects.
		182	bool hasNonControlEffects() { return hasNonArgNonControlEffects() \|\| hasArgEffects(); }
177		183
178	// Generate some code for this instruction. This is, like, literally our backend. If this is the	184	// Generate some code for this instruction. This is, like, literally our backend. If this is the
179	// terminal, it returns the jump that needs to be linked for the "then" case, with the "else"	185	// terminal, it returns the jump that needs to be linked for the "then" case, with the "else"



                }
            }

            // Now check if the block's terminal can be replaced with a jump. The terminal must not
            // have weird effects.
            if (block->numSuccessors() > 1 
                && !block->last().hasNonControlEffects()) {
                // All of the successors must be the same.
                bool allSame = true;
                BasicBlock* firstSuccessor = block->successorBlock(0);
                for (unsigned i = 1; i < block->numSuccessors(); ++i) {
                    if (block->successorBlock(i) != firstSuccessor) {
                        allSame = false;
                        break;
                            break;
                        }
                    }
                    if (allSame) {
                        if (verbose)
                            dataLog("Changing ", pointerDump(block), "'s terminal to a Jump.\n");
                        block->last() = Inst(Jump, block->last().origin);
                        block->successors().resize(1);
                        block->successors()[0].frequency() = FrequencyClass::Normal;
                        changed = true;
                    }
                }
                if (allSame) {
                    if (verbose)
                        dataLog("Changing ", pointerDump(block), "'s terminal to a Jump.\n");
                    block->last() = Inst(Jump, block->last().origin);
                    block->successors().resize(1);
                    block->successors()[0].frequency() = FrequencyClass::Normal;
                    changed = true;
                }
            }

            // Finally handle jumps to a block with one predecessor.
            if (block->numSuccessors() == 1
                && !block->last().hasNonControlEffects()) {
                BasicBlock* successor = block->successorBlock(0);
                if (successor != block && successor->numPredecessors() == 1) {
                    RELEASE_ASSERT(successor->predecessor(0) == block);

Lines 1-5 Source/JavaScriptCore/b3/air/AirSpecial.cpp_sec1
- Source/JavaScriptCore/b3/air/AirSpecial.cpp -2 / +7 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 55-61 Optional<unsigned> Special::shouldTryAli Source/JavaScriptCore/b3/air/AirSpecial.cpp_sec2
55	return Nullopt;	55	return Nullopt;
56	}	56	}
57		57
58	bool Special::hasNonArgNonControlEffects()	58	bool Special::isTerminal(Inst&)
		59	{
		60	return false;
		61	}
		62
		63	bool Special::hasNonArgNonControlEffects(Inst&)
59	{	64	{
60	return true;	65	return true;
61	}	66	}

Lines 1-5 Source/JavaScriptCore/b3/air/AirSpecial.h_sec1
- Source/JavaScriptCore/b3/air/AirSpecial.h -2 / +5 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 87-95 public: Source/JavaScriptCore/b3/air/AirSpecial.h_sec2
87		87
88	virtual const RegisterSet& extraEarlyClobberedRegs(Inst&) = 0;	88	virtual const RegisterSet& extraEarlyClobberedRegs(Inst&) = 0;
89	virtual const RegisterSet& extraClobberedRegs(Inst&) = 0;	89	virtual const RegisterSet& extraClobberedRegs(Inst&) = 0;
		90
		91	// By default, this returns false.
		92	virtual bool isTerminal(Inst&);
90		93
91	// By default, this returns true.	94	// By default, this returns true.
92	virtual bool hasNonArgNonControlEffects();	95	virtual bool hasNonArgNonControlEffects(Inst&);
93		96
94	void dump(PrintStream&) const;	97	void dump(PrintStream&) const;
95	void deepDump(PrintStream&) const;	98	void deepDump(PrintStream&) const;



/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

                }
                VALIDATE(inst.isValidForm(), ("At ", inst, " in ", *block));
                if (instIndex == block->size() - 1)
                    VALIDATE(inst.isTerminal(), ("At ", inst, " in ", *block));
                else
                    VALIDATE(!inst.isTerminal(), ("At ", inst, " in ", *block));

                // forEachArg must return Arg&'s that point into the args array.
                inst.forEachArg(



    outp.puts "return false; "
    outp.puts "}"

    outp.puts "inline bool isDefinitelyTerminal(Opcode opcode)"
    outp.puts "{"
    outp.puts "switch (opcode) {"
    didFindTerminals = false

    outp.puts "return false;"
    outp.puts "}"

    outp.puts "bool Inst::isTerminal()"
    outp.puts "{"
    outp.puts "switch (opcode) {"
    foundTrue = false
    $opcodes.values.each {
        | opcode |
        if opcode.attributes[:terminal]
            outp.puts "case #{opcode.name}:"
            foundTrue = true
        end
    }
    if foundTrue
        outp.puts "return true;"
    end
    $opcodes.values.each {
        | opcode |
        if opcode.custom
            outp.puts "case #{opcode.name}:"
            outp.puts "return #{opcode.name}Custom::isTerminal(*this);"
        end
    }
    outp.puts "default:"
    outp.puts "return false;"
    outp.puts "}"
    outp.puts "}"
    
    outp.puts "bool Inst::hasNonArgNonControlEffects()"
    outp.puts "{"
    outp.puts "switch (opcode) {"

Lines 30-36 Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp_sec1
- Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp +4 lines
30		30
31	#include "AirGenerationContext.h"	31	#include "AirGenerationContext.h"
32	#include "AllowMacroScratchRegisterUsage.h"	32	#include "AllowMacroScratchRegisterUsage.h"
		33	#include "B3CheckValue.h"
		34	#include "B3PatchpointValue.h"
		35	#include "B3SlotBaseValue.h"
33	#include "B3StackmapGenerationParams.h"	36	#include "B3StackmapGenerationParams.h"
		37	#include "B3ValueInlines.h"
34	#include "CallFrameShuffler.h"	38	#include "CallFrameShuffler.h"
35	#include "CodeBlockWithJITType.h"	39	#include "CodeBlockWithJITType.h"
36	#include "DFGAbstractInterpreterInlines.h"	40	#include "DFGAbstractInterpreterInlines.h"

Lines 28-35 Source/JavaScriptCore/ftl/FTLOutput.cpp_sec1
- Source/JavaScriptCore/ftl/FTLOutput.cpp -5 / +20 lines
28		28
29	#if ENABLE(FTL_JIT)	29	#if ENABLE(FTL_JIT)
30		30
		31	#include "B3ArgumentRegValue.h"
		32	#include "B3BasicBlockInlines.h"
		33	#include "B3CCallValue.h"
		34	#include "B3Const32Value.h"
		35	#include "B3ConstPtrValue.h"
31	#include "B3MathExtras.h"	36	#include "B3MathExtras.h"
		37	#include "B3MemoryValue.h"
		38	#include "B3SlotBaseValue.h"
32	#include "B3StackmapGenerationParams.h"	39	#include "B3StackmapGenerationParams.h"
		40	#include "B3SwitchValue.h"
		41	#include "B3UpsilonValue.h"
		42	#include "B3ValueInlines.h"
33	#include "SuperSampler.h"	43	#include "SuperSampler.h"
34		44
35	namespace JSC { namespace FTL {	45	namespace JSC { namespace FTL {
Lines 578-589 LValue Output::select(LValue value, LVal Source/JavaScriptCore/ftl/FTLOutput.cpp_sec2
578		588
579	void Output::jump(LBasicBlock destination)	589	void Output::jump(LBasicBlock destination)
580	{	590	{
581	m_block->appendNew<B3::ControlValue>(m_proc, B3::Jump, origin(), B3::FrequentedBlock(destination));	591	m_block->appendNewControlValue(m_proc, B3::Jump, origin(), B3::FrequentedBlock(destination));
582	}	592	}
583		593
584	void Output::branch(LValue condition, LBasicBlock taken, Weight takenWeight, LBasicBlock notTaken, Weight notTakenWeight)	594	void Output::branch(LValue condition, LBasicBlock taken, Weight takenWeight, LBasicBlock notTaken, Weight notTakenWeight)
585	{	595	{
586	m_block->appendNew<ControlValue>(	596	m_block->appendNewControlValue(
587	m_proc, B3::Branch, origin(), condition,	597	m_proc, B3::Branch, origin(), condition,
588	FrequentedBlock(taken, takenWeight.frequencyClass()),	598	FrequentedBlock(taken, takenWeight.frequencyClass()),
589	FrequentedBlock(notTaken, notTakenWeight.frequencyClass()));	599	FrequentedBlock(notTaken, notTakenWeight.frequencyClass()));
Lines 603-614 void Output::check(LValue condition, Wei Source/JavaScriptCore/ftl/FTLOutput.cpp_sec3
603		613
604	void Output::ret(LValue value)	614	void Output::ret(LValue value)
605	{	615	{
606	m_block->appendNew<B3::ControlValue>(m_proc, B3::Return, origin(), value);	616	m_block->appendNewControlValue(m_proc, B3::Return, origin(), value);
607	}	617	}
608		618
609	void Output::unreachable()	619	void Output::unreachable()
610	{	620	{
611	m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin());	621	m_block->appendNewControlValue(m_proc, B3::Oops, origin());
612	}	622	}
613		623
614	CheckValue* Output::speculate(LValue value)	624	CheckValue* Output::speculate(LValue value)
Lines 638-644 PatchpointValue* Output::patchpoint(LTyp Source/JavaScriptCore/ftl/FTLOutput.cpp_sec4
638		648
639	void Output::trap()	649	void Output::trap()
640	{	650	{
641	m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin());	651	m_block->appendNewControlValue(m_proc, B3::Oops, origin());
642	}	652	}
643		653
644	ValueFromBlock Output::anchor(LValue value)	654	ValueFromBlock Output::anchor(LValue value)
Lines 729-734 void Output::decrementSuperSamplerCount( Source/JavaScriptCore/ftl/FTLOutput.cpp_sec5
729	store32(sub(load32(counter), int32One), counter);	739	store32(sub(load32(counter), int32One), counter);
730	}	740	}
731		741
		742	void Output::addIncomingToPhi(LValue phi, ValueFromBlock value)
		743	{
		744	value.value()->as<B3::UpsilonValue>()->setPhi(phi);
		745	}
		746
732	} } // namespace JSC::FTL	747	} } // namespace JSC::FTL
733		748
734	#endif // ENABLE(FTL_JIT)	749	#endif // ENABLE(FTL_JIT)




#if ENABLE(FTL_JIT)

#include "B3ArgumentRegValue.h"
#include "B3BasicBlockInlines.h"
#include "B3CCallValue.h"
#include "B3Compilation.h"
#include "B3FrequentedBlock.h"
#include "B3ConstPtrValue.h"
#include "B3ControlValue.h"
#include "B3MemoryValue.h"
#include "B3Procedure.h"
#include "B3SlotBaseValue.h"
#include "B3SwitchValue.h"
#include "B3UpsilonValue.h"
#include "B3ValueInlines.h"
#include "FTLAbbreviatedTypes.h"
#include "FTLAbstractHeapRepository.h"
#include "FTLCommonValues.h"


namespace JSC {

namespace DFG {
struct Node;
} // namespace DFG

namespace B3 {
class SlotBaseValue;
} // namespace B3

namespace FTL {


    LValue constBool(bool value);
    LValue constInt32(int32_t value);
    template<typename T>
    LValue constIntPtr(T* value)
    {
        if (sizeof(void*) == 8)
            return constInt64(bitwise_cast<intptr_t>(value));
        return constInt32(bitwise_cast<intptr_t>(value));
    }
    template<typename T>
    LValue constIntPtr(T value)
    {
        if (sizeof(void*) == 8)
            return constInt64(static_cast<intptr_t>(value));
        return constInt32(static_cast<intptr_t>(value));
    }
    LValue constInt64(int64_t value);
    LValue constDouble(double value);


    LValue callWithoutSideEffects(B3::Type type, Function function, LValue arg1, Args... args)
    {
        return m_block->appendNew<B3::CCallValue>(m_proc, type, origin(), B3::Effects::none(),
            constIntPtr(bitwise_cast<void*>(function)), arg1, args...);
            arg1, args...);
    }

    template<typename FunctionType>

    template<typename VectorType>
    void switchInstruction(LValue value, const VectorType& cases, LBasicBlock fallThrough, Weight fallThroughWeight)
    {
        B3::SwitchValue* switchValue = m_block->appendNew<B3::SwitchValue>(m_proc, origin(), value);
        switchValue->setFallThrough(B3::FrequentedBlock(fallThrough));
        for (const SwitchCase& switchCase : cases) {
            int64_t value = switchCase.value()->asInt();
            B3::FrequentedBlock target(switchCase.target(), switchCase.weight().frequencyClass());

    return phiNode;
}

inline void Output::addIncomingToPhi(LValue phi, ValueFromBlock value)
{
    value.value()->as<B3::UpsilonValue>()->setPhi(phi);
}

template<typename... Params>
inline void Output::addIncomingToPhi(LValue phi, ValueFromBlock value, Params... theRest)
{



2016-05-29  Filip Pizlo  <fpizlo@apple.com>

        Implement table-based switches in B3/Air
        https://bugs.webkit.org/show_bug.cgi?id=151141

        Reviewed by NOBODY (OOPS!).
        
        Update documentation for the new PolyJump opcode.

        * docs/b3/intermediate-representation.html:

2016-07-01  Jon Davis  <jond@apple.com>

        Added a colorful new image and fixed the Open Graph attribute.

Lines 43-49 Websites/webkit.org/docs/b3/intermediate-representation.html_sec1
- Websites/webkit.org/docs/b3/intermediate-representation.html -3 / +21 lines
43	<p>The act of compiling the Procedure changes it in-place, making it unsuitable for	43	<p>The act of compiling the Procedure changes it in-place, making it unsuitable for
44	compiling again. Always create a new Procedure every time you want to compile	44	compiling again. Always create a new Procedure every time you want to compile
45	something.</p>	45	something.</p>
46		46
47	<h2>Types</h2>	47	<h2>Types</h2>
48		48
49	<p>B3 has a trivial type system with only five types:</p>	49	<p>B3 has a trivial type system with only five types:</p>
Lines 130-137 Websites/webkit.org/docs/b3/intermediate-representation.html_sec2
130	<h2>Control flow</h2>	130	<h2>Control flow</h2>
131		131
132	<p>B3 represents control flow using basic blocks. Each basic block may have zero or more	132	<p>B3 represents control flow using basic blocks. Each basic block may have zero or more
133	predecessors. Each basic block may have zero or more successors. The successors are	133	predecessors. Each basic block may have zero or more successors. The meaning of the
134	controlled by the basic block's last Value, which must be a ControlValue instance.</p>	134	successors is determined by the basic block's last Value, which must be a terminal. A
		135	value is terminal if:</p>
		136
		137	<pre><code>value->effects().terminal</code></pre>
		138
		139	<p>Some opcodes are definitely terminal, like Jump, Branch, Oops, Return, and Switch. But a
		140	value with the Patchpoint opcode may or may not be terminal. In general it's necessary to
		141	check the <code>terminal</code> bit as shown above.</p>
135		142
136	<p>Each basic block contains a Vector<Value*> as the contents of the block. Control	143	<p>Each basic block contains a Vector<Value*> as the contents of the block. Control
137	flow inside the block is implicit based on the order of Values in the vector.</p>	144	flow inside the block is implicit based on the order of Values in the vector.</p>
Lines 458-463 patchpoint->setGenerator( Websites/webkit.org/docs/b3/intermediate-representation.html_sec3
458	patchpoint will take some exit state as part of its arguments, and it will manipulate	465	patchpoint will take some exit state as part of its arguments, and it will manipulate
459	the call frame in place to make it look like another execution engine's call frame.	466	the call frame in place to make it look like another execution engine's call frame.
460	This is called OSR, and JavaScriptCore does it a lot.</p>	467	This is called OSR, and JavaScriptCore does it a lot.</p>
		468
		469	<p>A patchpoint can be used as a terminal. Simply set the <code>terminal</code> bit:</p>
		470
		471	<pre><code>patchpoint->effects.terminal = true;</code></pre>
		472
		473	<p>The generator can determine where to branch by using the StackmapGenerationParams to
		474	get the set of labels for all successors. You're guaranteed that the number of
		475	successors of the patchpoint's basic block will be the same as when you created it.
		476	However, like any value, a patchpoint may be cloned. This means, for example, that if
		477	you use this to implement a table jump then the jump table must be created inside the
		478	generator, so that you get one jump table per clone.</p>
461		479
462	<p>Must use the PatchpointValue class with the Patchpoint opcode.</p>	480	<p>Must use the PatchpointValue class with the Patchpoint opcode.</p>
463	</dd>	481	</dd>



2016-05-29  Filip Pizlo  <fpizlo@apple.com>

        Implement table-based switches in B3/Air
        https://bugs.webkit.org/show_bug.cgi?id=151141

        Reviewed by NOBODY (OOPS!).

        * js/regress/bigswitch-expected.txt: Added.
        * js/regress/bigswitch.html: Added.
        * js/regress/script-tests/bigswitch.js: Added.
        (foo):

2016-07-04  Yusuke Suzuki  <utatane.tea@gmail.com>

        Unreviewed, skip misc-bugs-847389-jpeg2000.js in jsc stress tests



JSRegress/bigswitch

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".


PASS no exception thrown
PASS successfullyParsed is true

TEST COMPLETE




<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
<html>
<head>
<script src="../../resources/js-test-pre.js"></script>
</head>
<body>
<script src="../../resources/regress-pre.js"></script>
<script src="script-tests/bigswitch.js"></script>
<script src="../../resources/regress-post.js"></script>
<script src="../../resources/js-test-post.js"></script>
</body>
</html>



function foo(o) {
    var result = 0;
    for (var i = 0; i < 1000; ++i) {
        var value = i & 63;
        switch (value) {
        case 0:
            result += o.a;
            break;
        case 1:
            result += o.b;
            break;
        case 2:
            result += o.c;
            break;
        case 3:
            result += o.d;
            break;
        case 4:
            result += o.e;
            break;
        case 5:
            result += o.f;
            break;
        case 6:
            result += o.g;
            break;
        case 7:
            result += o.h;
            break;
        case 8:
            result += o.i;
            break;
        case 9:
            result += o.j;
            break;
        case 10:
            result += o.k;
            break;
        case 11:
            result += o.a;
            break;
        case 12:
            result += o.b;
            break;
        case 13:
            result += o.c;
            break;
        case 14:
            result += o.d;
            break;
        case 15:
            result += o.e;
            break;
        case 16:
            result += o.f;
            break;
        case 17:
            result += o.g;
            break;
        case 18:
            result += o.h;
            break;
        case 19:
            result += o.i;
            break;
        case 20:
            result += o.j;
            break;
        case 21:
            result += o.k;
            break;
        case 22:
            result += o.k;
            break;
        case 23:
            result += o.a;
            break;
        case 24:
            result += o.b;
            break;
        case 25:
            result += o.c;
            break;
        case 26:
            result += o.d;
            break;
        case 27:
            result += o.e;
            break;
        case 28:
            result += o.f;
            break;
        case 29:
            result += o.g;
            break;
        case 30:
            result += o.h;
            break;
        case 31:
            result += o.i;
            break;
        case 32:
            result += o.j;
            break;
        case 33:
            result += o.k;
            break;
        case 34:
            result += o.k;
            break;
        case 35:
            result += o.k;
            break;
        case 36:
            result += o.a;
            break;
        case 37:
            result += o.b;
            break;
        case 38:
            result += o.c;
            break;
        case 39:
            result += o.d;
            break;
        case 40:
            result += o.e;
            break;
        case 41:
            result += o.f;
            break;
        case 42:
            result += o.g;
            break;
        case 43:
            result += o.h;
            break;
        case 44:
            result += o.i;
            break;
        case 45:
            result += o.j;
            break;
        case 46:
            result += o.k;
            break;
        case 47:
            result += o.i;
            break;
        case 48:
            result += o.j;
            break;
        case 49:
            result += o.k;
            break;
        case 50:
            result += o.k;
            break;
        case 51:
            result += o.k;
            break;
        case 52:
            result += o.a;
            break;
        case 53:
            result += o.b;
            break;
        case 54:
            result += o.c;
            break;
        case 55:
            result += o.d;
            break;
        case 56:
            result += o.e;
            break;
        case 57:
            result += o.f;
            break;
        case 58:
            result += o.g;
            break;
        case 59:
            result += o.h;
            break;
        case 60:
            result += o.i;
            break;
        case 61:
            result += o.j;
            break;
        case 62:
            result += o.k;
            break;
        default:
            result += o.z;
            break;
        }
    }
    return result;
}

(function() {
    var o = {a:1, b:2, c:3, d:4, e:5, f:6, g:7, h:8, i:9, j:10, k:11, z:100};
    var result = 0;
    for (var i = 0; i < 10000; ++i)
        result += foo(o);
    if (result != 79660000)
        throw "Error: bad result: " + result;
})();


Return to Bug 151141

Lines 1-3 Source/JavaScriptCore/ChangeLog_sec1
- Source/JavaScriptCore/ChangeLog +163 lines
		1	2016-05-29 Filip Pizlo <fpizlo@apple.com>
		2
		3	Implement table-based switches in B3/Air
		4	https://bugs.webkit.org/show_bug.cgi?id=151141
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	If a switch statement gets large, it's better to express it as an indirect jump rather than
		9	using a binary switch (divide-and-conquer tree of comparisons leading to O(log n) branches to
		10	get to the switch case). When dealing with integer switches, FTL will already use the B3
		11	Switch and expect this to get lowered as efficiently as possible; it's a bug that B3 will
		12	always use a binary switch rather than indirect jumps. When dealing with switches over some
		13	more sophisticated types, we'd want FTL to build an indirect jump table itself and use
		14	something like a hashtable to feed it. In that case, there will be no B3 Switch; we'll want
		15	some kind of indirect jump instruction.
		16
		17	This implies that we want B3 to have the ability to lower Switch to indirect jumps and to
		18	expose those indirect jumps in IR so that the FTL could do its own indirect jumps for
		19	switches over more complicated things like strings. This change introduces an indirect jump
		20	instruction to B3 and calls it PolyJump. It has some unique semantics that make it very
		21	different from "indirect jumps", "indirect branches", and "computed gotos" - all terms of art
		22	used in other compilers.
		23
		24	This implements the most basic kind of Switch-to-PolyJump lowering in B3::lowerMacros(). As
		25	part of the existing divide-and-conquer that creates branches, if it detects that the set of
		26	cases satisfies some conditions (density of case values and total size), then it will emit a
		27	PolyJump.
		28
		29	The problem with classic indirect jumps is that they force the compiler to be conservative
		30	about control flow. The compiler must assume that the indirect jump may transfer control flow
		31	to any escaped block (block labeled as being a possible target for indirect jumps, or if no
		32	such labeling is available, the compiler must assume that it may target any block). The worst
		33	part is that the implicit control flow edges from the indirect jump to the escaped blocks
		34	cannot be broken. This invalidates a principle of B3 IR: any phase may break any critical
		35	edge for any reason. Our SSA conversion would break if we revoked this feature. It's actually
		36	much worse than this - basically any logic over control flow would have to be hacked to deal
		37	with these unbreakable edges. This would mean changing all CFG transformation utilities and
		38	passes. We have a lot of those and we want it to be easy to write new ones.
		39
		40	This is why we use something new and quite different from classic indirect jumps. PolyJump
		41	makes the control flow edges explicit. The client must supply the successors when it creates
		42	the PolyJump. The compiler may rewire those successor edges the same way that it would rewire
		43	any control flow edges. Consequently the vast majority of CFG reasoning in B3 is unchanged.
		44	If you don't want to understand PolyJump, just think of it like you would a Switch with an
		45	opaque incoming value. This works because we do not add any notion of escaped basic blocks.
		46	Instead of letting the client get the pointers to basic blocks by escaping them like in LLVM,
		47	you can only get the pointers of the successors of PolyJump by registering a callback with
		48	PolyJump. This callback doesn't actually give you the addresses of basic blocks. It just
		49	gives you the addresses where you must jump to transfer control flow from that PolyJump to
		50	its successors. This means that the magic of PolyJump is confined only to the PolyJump itself
		51	and doesn't infect reasoning about the basic blocks that it jumps to.
		52
		53	The only downside is that that PolyJump is not cloneable. You can't clone it because if you
		54	did, then the two resulting PolyJumps may have their successor edges rewired independently of
		55	each other. This could easily happen if we break critical edges. If that did happen then it
		56	would break the client of PolyJump: they would have already created something like a jump
		57	table and will be populating it via the callback, but now the callback will be called twice,
		58	and may return different jump destinations each time. So, this patch introduces
		59	Value::isCloneable() and teaches both of our code specialization optimizations (tail
		60	duplication and select specialization) to bail if the code they want to specialize is not
		61	cloneable. This is totally benign most of the time, since those optimizations usually run
		62	before Switch lowering. Clients that use PolyJump directly have to appreciate the trade-off:
		63	PolyJump may gain them some performance but they are opting out of optimizations that use
		64	cloning. A close corollary of the no-clone rule is that the client cannot create multiple
65	PolyJumps that are fed by a common jump table: the fact that each PolyJump has a callback
66	that just tells you the jump destinations for its successor edges, not successor blocks,
67	means that if you create two PolyJumps and give them the same successor list, you are not
68	guaranteed that they will get the same jump destinations. This hurts if you want to use
69	PolyJump for threaded interpreters but it's harmless for switch lowering. The goal of
70	PolyJump is to be awesome for switch lowering while not breaking the rest of the compiler, so
71	this is probably fine.
72
73	The isCloneable() method currently only returns true for PolyJump, but I anticipate we will
74	add other non-cloneable things later. I think is is inherent in a compiler that allows such
75	customizeability for its clients. For example, we may want to add a flag to Patchpoint that
76	makes it non-cloneable. Sometimes we have to jump through hoops in the FTL because of the
77	cloneability of patchpoints. This happens in OSR exits, which pay a significant memory cost
78	for additional data structures that are there in case an exit gets cloned. It may be more
79	profitable to just say that OSR exits (i.e. Checks and InvalidationPoint Patchpoints) are not
80	cloneable. Surely this would reduce tail duplication, but tail duplication is most profitable
81	when it clones only a tiny amount of code; if there's an exit then we're not talking about a
82	tiny amount of code anymore.
83
84	This is a ~30% speed-up on microbenchmarks that have big switch statements (~60 cases). It's
85	not a speed-up on mainstream benchmarks.
86
87	This also adds a new test to testb3 for PolyJump, Get, and Set. The FTL does not currently
88	use PolyJump directly, but we want this to be possible. It also doesn't use Get/Set directly
89	even though we want this to be possible. It's important to test these since opcodes that
90	result from lowering don't affect early phases, so we could have regressions in early phases
91	related to these opcodes that wouldn't be caught by any JS test. So, this adds a very basic
92	threaded interpreter to testb3 for a Brainfuck-style language, and tests it by having it run
93	a program that prints the numbers 1..100 in a loop. Unlike a real threaded interpreter, it
94	uses a common dispatch block rather than having dispatch at the terminus of each opcode.
95	That's necessary because PolyJump is not cloneable. The state of the interpreter is
96	represented using Variables that we Get and Set, so it tests Get/Set as well.
97
98	* CMakeLists.txt:
99	* JavaScriptCore.xcodeproj/project.pbxproj:
100	* assembler/MacroAssemblerX86Common.h:
101	(JSC::MacroAssemblerX86Common::jump):
102	* assembler/X86Assembler.h:
103	(JSC::X86Assembler::jmp_m):
104	* b3/B3BasicBlock.cpp:
105	(JSC::B3::BasicBlock::updatePredecessorsAfter):
106	(JSC::B3::BasicBlock::isCloneable):
107	(JSC::B3::BasicBlock::dump):
108	* b3/B3BasicBlock.h:
109	(JSC::B3::BasicBlock::frequency):
110	* b3/B3Common.h:
111	(JSC::B3::is64Bit):
112	* b3/B3ControlValue.h:
113	* b3/B3DataSection.cpp:
114	(JSC::B3::DataSection::DataSection):
115	* b3/B3DuplicateTails.cpp:
116	* b3/B3LowerMacros.cpp:
117	* b3/B3LowerToAir.cpp:
118	(JSC::B3::Air::LowerToAir::lower):
119	* b3/B3Opcode.cpp:
120	(WTF::printInternal):
121	* b3/B3Opcode.h:
122	* b3/B3PolyJumpValue.cpp: Added.
123	(JSC::B3::PolyJumpValue::~PolyJumpValue):
124	(JSC::B3::PolyJumpValue::appendSuccessor):
125	(JSC::B3::PolyJumpValue::setCallbackTask):
126	(JSC::B3::PolyJumpValue::isCloneable):
127	(JSC::B3::PolyJumpValue::dumpMeta):
128	(JSC::B3::PolyJumpValue::cloneImpl):
129	(JSC::B3::PolyJumpValue::PolyJumpValue):
130	* b3/B3PolyJumpValue.h: Added.
131	(JSC::B3::PolyJumpValue::accepts):
132	(JSC::B3::PolyJumpValue::setCallback):
133	(JSC::B3::PolyJumpValue::callbackTask):
134	* b3/B3Procedure.cpp:
135	(JSC::B3::Procedure::clone):
136	* b3/B3Procedure.h:
137	(JSC::B3::Procedure::lastPhaseName):
138	(JSC::B3::Procedure::byproducts):
139	* b3/B3ReduceStrength.cpp:
140	* b3/B3Validate.cpp:
141	* b3/B3Value.cpp:
142	(JSC::B3::Value::effects):
143	(JSC::B3::Value::isCloneable):
144	(JSC::B3::Value::key):
145	* b3/B3Value.h:
146	* b3/air/AirCode.h:
147	* b3/air/AirGenerate.cpp:
148	(JSC::B3::Air::generate):
149	* b3/air/AirInst.cpp:
150	(JSC::B3::Air::Inst::hasArgEffects):
151	(JSC::B3::Air::Inst::isCloneable):
152	(JSC::B3::Air::Inst::dump):
153	* b3/air/AirInst.h:
154	* b3/air/AirOpcode.opcodes:
155	* b3/testb3.cpp:
156	(JSC::B3::shouldBeVerbose):
157	(JSC::B3::testSwitchChillDiv):
158	(JSC::B3::testLateRegister):
159	(JSC::B3::threadedInterpreterPrint):
160	(JSC::B3::testThreadedInterpreter):
161	(JSC::B3::zero):
162	(JSC::B3::run):
163
1	2016-07-03 Per Arne Vollan <pvollan@apple.com>	164	2016-07-03 Per Arne Vollan <pvollan@apple.com>
2		165
3	[Win] DLLs are missing version information.	166	[Win] DLLs are missing version information.

Lines 108-113 set(JavaScriptCore_SOURCES Source/JavaScriptCore/CMakeLists.txt_sec1
- Source/JavaScriptCore/CMakeLists.txt -1 / +1 lines
108	b3/B3BlockInsertionSet.cpp	108	b3/B3BlockInsertionSet.cpp
109	b3/B3BreakCriticalEdges.cpp	109	b3/B3BreakCriticalEdges.cpp
110	b3/B3CCallValue.cpp	110	b3/B3CCallValue.cpp
		111	b3/B3CaseCollection.cpp
111	b3/B3CheckSpecial.cpp	112	b3/B3CheckSpecial.cpp
112	b3/B3CheckValue.cpp	113	b3/B3CheckValue.cpp
113	b3/B3Common.cpp	114	b3/B3Common.cpp
Lines 118-124 set(JavaScriptCore_SOURCES Source/JavaScriptCore/CMakeLists.txt_sec2
118	b3/B3ConstDoubleValue.cpp	119	b3/B3ConstDoubleValue.cpp
119	b3/B3ConstFloatValue.cpp	120	b3/B3ConstFloatValue.cpp
120	b3/B3ConstrainedValue.cpp	121	b3/B3ConstrainedValue.cpp
121	b3/B3ControlValue.cpp
122	b3/B3DataSection.cpp	122	b3/B3DataSection.cpp
123	b3/B3DuplicateTails.cpp	123	b3/B3DuplicateTails.cpp
124	b3/B3Effects.cpp	124	b3/B3Effects.cpp

Lines 773-780 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec1
- Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj -8 / +12 lines
773	0FEC85101BDACDAC0080FF74 /* B3Const64Value.h in Headers / = {isa = PBXBuildFile; fileRef = 0FEC84C61BDACDAC0080FF74 / B3Const64Value.h */; };	773	0FEC85101BDACDAC0080FF74 /* B3Const64Value.h in Headers / = {isa = PBXBuildFile; fileRef = 0FEC84C61BDACDAC0080FF74 / B3Const64Value.h */; };
774	0FEC85111BDACDAC0080FF74 /* B3ConstDoubleValue.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0FEC84C71BDACDAC0080FF74 / B3ConstDoubleValue.cpp */; };	774	0FEC85111BDACDAC0080FF74 /* B3ConstDoubleValue.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0FEC84C71BDACDAC0080FF74 / B3ConstDoubleValue.cpp */; };
775	0FEC85121BDACDAC0080FF74 /* B3ConstDoubleValue.h in Headers / = {isa = PBXBuildFile; fileRef = 0FEC84C81BDACDAC0080FF74 / B3ConstDoubleValue.h */; };	775	0FEC85121BDACDAC0080FF74 /* B3ConstDoubleValue.h in Headers / = {isa = PBXBuildFile; fileRef = 0FEC84C81BDACDAC0080FF74 / B3ConstDoubleValue.h */; };
776	0FEC85131BDACDAC0080FF74 /* B3ControlValue.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0FEC84C91BDACDAC0080FF74 / B3ControlValue.cpp */; };
777	0FEC85141BDACDAC0080FF74 /* B3ControlValue.h in Headers / = {isa = PBXBuildFile; fileRef = 0FEC84CA1BDACDAC0080FF74 / B3ControlValue.h */; };
778	0FEC85151BDACDAC0080FF74 /* B3FrequencyClass.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0FEC84CB1BDACDAC0080FF74 / B3FrequencyClass.cpp */; };	776	0FEC85151BDACDAC0080FF74 /* B3FrequencyClass.cpp in Sources / = {isa = PBXBuildFile; fileRef = 0FEC84CB1BDACDAC0080FF74 / B3FrequencyClass.cpp */; };
779	0FEC85161BDACDAC0080FF74 /* B3FrequencyClass.h in Headers / = {isa = PBXBuildFile; fileRef = 0FEC84CC1BDACDAC0080FF74 / B3FrequencyClass.h */; };	777	0FEC85161BDACDAC0080FF74 /* B3FrequencyClass.h in Headers / = {isa = PBXBuildFile; fileRef = 0FEC84CC1BDACDAC0080FF74 / B3FrequencyClass.h */; };
780	0FEC85171BDACDAC0080FF74 /* B3FrequentedBlock.h in Headers / = {isa = PBXBuildFile; fileRef = 0FEC84CD1BDACDAC0080FF74 / B3FrequentedBlock.h */; };	778	0FEC85171BDACDAC0080FF74 /* B3FrequentedBlock.h in Headers / = {isa = PBXBuildFile; fileRef = 0FEC84CD1BDACDAC0080FF74 / B3FrequentedBlock.h */; };
Lines 1997-2002 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec2
1997	DC69AA661CF7A1F200C6272F /* MatchResult.cpp in Sources / = {isa = PBXBuildFile; fileRef = DC69AA651CF7A1EF00C6272F / MatchResult.cpp */; };	1995	DC69AA661CF7A1F200C6272F /* MatchResult.cpp in Sources / = {isa = PBXBuildFile; fileRef = DC69AA651CF7A1EF00C6272F / MatchResult.cpp */; };
1998	DC7997831CDE9FA0004D4A09 /* TagRegistersMode.h in Headers / = {isa = PBXBuildFile; fileRef = DC7997821CDE9F9E004D4A09 / TagRegistersMode.h */; settings = {ATTRIBUTES = (Private, ); }; };	1996	DC7997831CDE9FA0004D4A09 /* TagRegistersMode.h in Headers / = {isa = PBXBuildFile; fileRef = DC7997821CDE9F9E004D4A09 / TagRegistersMode.h */; settings = {ATTRIBUTES = (Private, ); }; };
1999	DC7997841CDE9FA2004D4A09 /* TagRegistersMode.cpp in Sources / = {isa = PBXBuildFile; fileRef = DC7997811CDE9F9E004D4A09 / TagRegistersMode.cpp */; };	1997	DC7997841CDE9FA2004D4A09 /* TagRegistersMode.cpp in Sources / = {isa = PBXBuildFile; fileRef = DC7997811CDE9F9E004D4A09 / TagRegistersMode.cpp */; };
		1998	DC9A0C1F1D2D9CB10085124E /* B3CaseCollectionInlines.h in Headers / = {isa = PBXBuildFile; fileRef = DC9A0C1E1D2D94EF0085124E / B3CaseCollectionInlines.h */; };
		1999	DC9A0C201D2D9CB30085124E /* B3CaseCollection.h in Headers / = {isa = PBXBuildFile; fileRef = DC9A0C1D1D2D94EF0085124E / B3CaseCollection.h */; };
		2000	DC9A0C211D2D9CB40085124E /* B3CaseCollection.cpp in Sources / = {isa = PBXBuildFile; fileRef = DC9A0C1C1D2D94EF0085124E / B3CaseCollection.cpp */; };
2000	DCEE22091CEB9895000C2396 /* DFGBackwardsCFG.h in Headers / = {isa = PBXBuildFile; fileRef = DCEE22061CEB9890000C2396 / DFGBackwardsCFG.h */; };	2001	DCEE22091CEB9895000C2396 /* DFGBackwardsCFG.h in Headers / = {isa = PBXBuildFile; fileRef = DCEE22061CEB9890000C2396 / DFGBackwardsCFG.h */; };
2001	DCEE220A1CEB9895000C2396 /* DFGBackwardsDominators.h in Headers / = {isa = PBXBuildFile; fileRef = DCEE22071CEB9890000C2396 / DFGBackwardsDominators.h */; };	2002	DCEE220A1CEB9895000C2396 /* DFGBackwardsDominators.h in Headers / = {isa = PBXBuildFile; fileRef = DCEE22071CEB9890000C2396 / DFGBackwardsDominators.h */; };
2002	DCEE220B1CEB9895000C2396 /* DFGControlEquivalenceAnalysis.h in Headers / = {isa = PBXBuildFile; fileRef = DCEE22081CEB9890000C2396 / DFGControlEquivalenceAnalysis.h */; };	2003	DCEE220B1CEB9895000C2396 /* DFGControlEquivalenceAnalysis.h in Headers / = {isa = PBXBuildFile; fileRef = DCEE22081CEB9890000C2396 / DFGControlEquivalenceAnalysis.h */; };
Lines 2964-2971 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec3
2964	0FEC84C61BDACDAC0080FF74 /* B3Const64Value.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3Const64Value.h; path = b3/B3Const64Value.h; sourceTree = "<group>"; };	2965	0FEC84C61BDACDAC0080FF74 /* B3Const64Value.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3Const64Value.h; path = b3/B3Const64Value.h; sourceTree = "<group>"; };
2965	0FEC84C71BDACDAC0080FF74 /* B3ConstDoubleValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = B3ConstDoubleValue.cpp; path = b3/B3ConstDoubleValue.cpp; sourceTree = "<group>"; };	2966	0FEC84C71BDACDAC0080FF74 /* B3ConstDoubleValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = B3ConstDoubleValue.cpp; path = b3/B3ConstDoubleValue.cpp; sourceTree = "<group>"; };
2966	0FEC84C81BDACDAC0080FF74 /* B3ConstDoubleValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3ConstDoubleValue.h; path = b3/B3ConstDoubleValue.h; sourceTree = "<group>"; };	2967	0FEC84C81BDACDAC0080FF74 /* B3ConstDoubleValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3ConstDoubleValue.h; path = b3/B3ConstDoubleValue.h; sourceTree = "<group>"; };
2967	0FEC84C91BDACDAC0080FF74 /* B3ControlValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = B3ControlValue.cpp; path = b3/B3ControlValue.cpp; sourceTree = "<group>"; };
2968	0FEC84CA1BDACDAC0080FF74 /* B3ControlValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3ControlValue.h; path = b3/B3ControlValue.h; sourceTree = "<group>"; };
2969	0FEC84CB1BDACDAC0080FF74 /* B3FrequencyClass.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = B3FrequencyClass.cpp; path = b3/B3FrequencyClass.cpp; sourceTree = "<group>"; };	2968	0FEC84CB1BDACDAC0080FF74 /* B3FrequencyClass.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = B3FrequencyClass.cpp; path = b3/B3FrequencyClass.cpp; sourceTree = "<group>"; };
2970	0FEC84CC1BDACDAC0080FF74 /* B3FrequencyClass.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3FrequencyClass.h; path = b3/B3FrequencyClass.h; sourceTree = "<group>"; };	2969	0FEC84CC1BDACDAC0080FF74 /* B3FrequencyClass.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3FrequencyClass.h; path = b3/B3FrequencyClass.h; sourceTree = "<group>"; };
2971	0FEC84CD1BDACDAC0080FF74 /* B3FrequentedBlock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3FrequentedBlock.h; path = b3/B3FrequentedBlock.h; sourceTree = "<group>"; };	2970	0FEC84CD1BDACDAC0080FF74 /* B3FrequentedBlock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3FrequentedBlock.h; path = b3/B3FrequentedBlock.h; sourceTree = "<group>"; };
Lines 4225-4230 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec4
4225	DC69AA651CF7A1EF00C6272F /* MatchResult.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MatchResult.cpp; sourceTree = "<group>"; };	4224	DC69AA651CF7A1EF00C6272F /* MatchResult.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MatchResult.cpp; sourceTree = "<group>"; };
4226	DC7997811CDE9F9E004D4A09 /* TagRegistersMode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TagRegistersMode.cpp; sourceTree = "<group>"; };	4225	DC7997811CDE9F9E004D4A09 /* TagRegistersMode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TagRegistersMode.cpp; sourceTree = "<group>"; };
4227	DC7997821CDE9F9E004D4A09 /* TagRegistersMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TagRegistersMode.h; sourceTree = "<group>"; };	4226	DC7997821CDE9F9E004D4A09 /* TagRegistersMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TagRegistersMode.h; sourceTree = "<group>"; };
		4227	DC9A0C1C1D2D94EF0085124E /* B3CaseCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = B3CaseCollection.cpp; path = b3/B3CaseCollection.cpp; sourceTree = "<group>"; };
		4228	DC9A0C1D1D2D94EF0085124E /* B3CaseCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3CaseCollection.h; path = b3/B3CaseCollection.h; sourceTree = "<group>"; };
		4229	DC9A0C1E1D2D94EF0085124E /* B3CaseCollectionInlines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = B3CaseCollectionInlines.h; path = b3/B3CaseCollectionInlines.h; sourceTree = "<group>"; };
4228	DCEE22061CEB9890000C2396 /* DFGBackwardsCFG.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGBackwardsCFG.h; path = dfg/DFGBackwardsCFG.h; sourceTree = "<group>"; };	4230	DCEE22061CEB9890000C2396 /* DFGBackwardsCFG.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGBackwardsCFG.h; path = dfg/DFGBackwardsCFG.h; sourceTree = "<group>"; };
4229	DCEE22071CEB9890000C2396 /* DFGBackwardsDominators.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGBackwardsDominators.h; path = dfg/DFGBackwardsDominators.h; sourceTree = "<group>"; };	4231	DCEE22071CEB9890000C2396 /* DFGBackwardsDominators.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGBackwardsDominators.h; path = dfg/DFGBackwardsDominators.h; sourceTree = "<group>"; };
4230	DCEE22081CEB9890000C2396 /* DFGControlEquivalenceAnalysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGControlEquivalenceAnalysis.h; path = dfg/DFGControlEquivalenceAnalysis.h; sourceTree = "<group>"; };	4232	DCEE22081CEB9890000C2396 /* DFGControlEquivalenceAnalysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGControlEquivalenceAnalysis.h; path = dfg/DFGControlEquivalenceAnalysis.h; sourceTree = "<group>"; };
Lines 4690-4695 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec5
4690	DCFDFBD71D1F5D9800FE3D72 /* B3BottomProvider.h */,	4692	DCFDFBD71D1F5D9800FE3D72 /* B3BottomProvider.h */,
4691	0F6B8ADE1C4EFE1700969052 /* B3BreakCriticalEdges.cpp */,	4693	0F6B8ADE1C4EFE1700969052 /* B3BreakCriticalEdges.cpp */,
4692	0F6B8ADF1C4EFE1700969052 /* B3BreakCriticalEdges.h */,	4694	0F6B8ADF1C4EFE1700969052 /* B3BreakCriticalEdges.h */,
		4695	DC9A0C1C1D2D94EF0085124E /* B3CaseCollection.cpp */,
		4696	DC9A0C1D1D2D94EF0085124E /* B3CaseCollection.h */,
		4697	DC9A0C1E1D2D94EF0085124E /* B3CaseCollectionInlines.h */,
4693	0F338DF71BE96AA80013C88F /* B3CCallValue.cpp */,	4698	0F338DF71BE96AA80013C88F /* B3CCallValue.cpp */,
4694	0F338DF81BE96AA80013C88F /* B3CCallValue.h */,	4699	0F338DF81BE96AA80013C88F /* B3CCallValue.h */,
4695	0F33FCF91C1625BE00323F67 /* B3CFG.h */,	4700	0F33FCF91C1625BE00323F67 /* B3CFG.h */,
Lines 4715-4722 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec6
4715	0FEC85B21BDED9570080FF74 /* B3ConstPtrValue.h */,	4720	0FEC85B21BDED9570080FF74 /* B3ConstPtrValue.h */,
4716	0F338DF31BE93D550013C88F /* B3ConstrainedValue.cpp */,	4721	0F338DF31BE93D550013C88F /* B3ConstrainedValue.cpp */,
4717	0F338DF41BE93D550013C88F /* B3ConstrainedValue.h */,	4722	0F338DF41BE93D550013C88F /* B3ConstrainedValue.h */,
4718	0FEC84C91BDACDAC0080FF74 /* B3ControlValue.cpp */,
4719	0FEC84CA1BDACDAC0080FF74 /* B3ControlValue.h */,
4720	0F338E011BF0276C0013C88F /* B3DataSection.cpp */,	4723	0F338E011BF0276C0013C88F /* B3DataSection.cpp */,
4721	0F338E021BF0276C0013C88F /* B3DataSection.h */,	4724	0F338E021BF0276C0013C88F /* B3DataSection.h */,
4722	0F33FCFA1C1625BE00323F67 /* B3Dominators.h */,	4725	0F33FCFA1C1625BE00323F67 /* B3Dominators.h */,
Lines 7068-7074 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec7
7068	0FEC85101BDACDAC0080FF74 /* B3Const64Value.h in Headers */,	7071	0FEC85101BDACDAC0080FF74 /* B3Const64Value.h in Headers */,
7069	0FEC85121BDACDAC0080FF74 /* B3ConstDoubleValue.h in Headers */,	7072	0FEC85121BDACDAC0080FF74 /* B3ConstDoubleValue.h in Headers */,
7070	0FEC85B31BDED9570080FF74 /* B3ConstPtrValue.h in Headers */,	7073	0FEC85B31BDED9570080FF74 /* B3ConstPtrValue.h in Headers */,
7071	0FEC85141BDACDAC0080FF74 /* B3ControlValue.h in Headers */,
7072	0FEC85C11BE167A00080FF74 /* B3Effects.h in Headers */,	7074	0FEC85C11BE167A00080FF74 /* B3Effects.h in Headers */,
7073	0FEC85161BDACDAC0080FF74 /* B3FrequencyClass.h in Headers */,	7075	0FEC85161BDACDAC0080FF74 /* B3FrequencyClass.h in Headers */,
7074	0F61832F1C45BF070072450B /* AirLowerAfterRegAlloc.h in Headers */,	7076	0F61832F1C45BF070072450B /* AirLowerAfterRegAlloc.h in Headers */,
Lines 7225-7230 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec8
7225	BC18C3FB0E16F5CD00B34460 /* DebuggerCallFrame.h in Headers */,	7227	BC18C3FB0E16F5CD00B34460 /* DebuggerCallFrame.h in Headers */,
7226	6AD2CB4D19B9140100065719 /* DebuggerEvalEnabler.h in Headers */,	7228	6AD2CB4D19B9140100065719 /* DebuggerEvalEnabler.h in Headers */,
7227	FEA08621182B7A0400F6D851 /* DebuggerPrimitives.h in Headers */,	7229	FEA08621182B7A0400F6D851 /* DebuggerPrimitives.h in Headers */,
		7230	DC9A0C1F1D2D9CB10085124E /* B3CaseCollectionInlines.h in Headers */,
7228	0F2D4DDE19832D34007D4B19 /* DebuggerScope.h in Headers */,	7231	0F2D4DDE19832D34007D4B19 /* DebuggerScope.h in Headers */,
7229	0F136D4D174AD69E0075B354 /* DeferGC.h in Headers */,	7232	0F136D4D174AD69E0075B354 /* DeferGC.h in Headers */,
7230	0FC712DF17CD877C008CC93C /* DeferredCompilationCallback.h in Headers */,	7233	0FC712DF17CD877C008CC93C /* DeferredCompilationCallback.h in Headers */,
Lines 7478-7483 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec9
7478	0FE0E4AE1C24C94A002E17B6 /* AirTmpWidth.h in Headers */,	7481	0FE0E4AE1C24C94A002E17B6 /* AirTmpWidth.h in Headers */,
7479	A7F2996C17A0BB670010417A /* FTLFail.h in Headers */,	7482	A7F2996C17A0BB670010417A /* FTLFail.h in Headers */,
7480	0FEA0A2C170B661900BB722C /* FTLFormattedValue.h in Headers */,	7483	0FEA0A2C170B661900BB722C /* FTLFormattedValue.h in Headers */,
		7484	DC9A0C201D2D9CB30085124E /* B3CaseCollection.h in Headers */,
7481	0FD8A31A17D51F2200CA2C40 /* FTLForOSREntryJITCode.h in Headers */,	7485	0FD8A31A17D51F2200CA2C40 /* FTLForOSREntryJITCode.h in Headers */,
7482	A78A977F179738D5009DF744 /* FTLGeneratedFunction.h in Headers */,	7486	A78A977F179738D5009DF744 /* FTLGeneratedFunction.h in Headers */,
7483	0FEA0A0E170513DB00BB722C /* FTLJITCode.h in Headers */,	7487	0FEA0A0E170513DB00BB722C /* FTLJITCode.h in Headers */,
Lines 8711-8717 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec10
8711	436E54541C468E7700B5AF73 /* B3LegalizeMemoryOffsets.cpp in Sources */,	8715	436E54541C468E7700B5AF73 /* B3LegalizeMemoryOffsets.cpp in Sources */,
8712	0FEC850F1BDACDAC0080FF74 /* B3Const64Value.cpp in Sources */,	8716	0FEC850F1BDACDAC0080FF74 /* B3Const64Value.cpp in Sources */,
8713	0FEC85111BDACDAC0080FF74 /* B3ConstDoubleValue.cpp in Sources */,	8717	0FEC85111BDACDAC0080FF74 /* B3ConstDoubleValue.cpp in Sources */,
8714	0FEC85131BDACDAC0080FF74 /* B3ControlValue.cpp in Sources */,
8715	0FEC85C51BE16F5A0080FF74 /* B3Effects.cpp in Sources */,	8718	0FEC85C51BE16F5A0080FF74 /* B3Effects.cpp in Sources */,
8716	0FEC85151BDACDAC0080FF74 /* B3FrequencyClass.cpp in Sources */,	8719	0FEC85151BDACDAC0080FF74 /* B3FrequencyClass.cpp in Sources */,
8717	0FEC85181BDACDAC0080FF74 /* B3Generate.cpp in Sources */,	8720	0FEC85181BDACDAC0080FF74 /* B3Generate.cpp in Sources */,
Lines 9156-9161 Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec11
9156	147F39D2107EC37600427A48 /* JSGlobalObject.cpp in Sources */,	9159	147F39D2107EC37600427A48 /* JSGlobalObject.cpp in Sources */,
9157	A5FD0085189B1B7E00633231 /* JSGlobalObjectConsoleAgent.cpp in Sources */,	9160	A5FD0085189B1B7E00633231 /* JSGlobalObjectConsoleAgent.cpp in Sources */,
9158	A5C3A1A518C0490200C9593A /* JSGlobalObjectConsoleClient.cpp in Sources */,	9161	A5C3A1A518C0490200C9593A /* JSGlobalObjectConsoleClient.cpp in Sources */,
		9162	DC9A0C211D2D9CB40085124E /* B3CaseCollection.cpp in Sources */,
9159	A59455921824744700CC3843 /* JSGlobalObjectDebuggable.cpp in Sources */,	9163	A59455921824744700CC3843 /* JSGlobalObjectDebuggable.cpp in Sources */,
9160	A57D23E91891B0770031C7FA /* JSGlobalObjectDebuggerAgent.cpp in Sources */,	9164	A57D23E91891B0770031C7FA /* JSGlobalObjectDebuggerAgent.cpp in Sources */,
9161	14E9D17B107EC469004DDA21 /* JSGlobalObjectFunctions.cpp in Sources */,	9165	14E9D17B107EC469004DDA21 /* JSGlobalObjectFunctions.cpp in Sources */,

Lines 30-36 Source/JavaScriptCore/b3/B3BasicBlock.cpp_sec1
- Source/JavaScriptCore/b3/B3BasicBlock.cpp -2 / +71 lines
30		30
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3BasicBlockUtils.h"	32	#include "B3BasicBlockUtils.h"
33	#include "B3ControlValue.h"
34	#include "B3Procedure.h"	33	#include "B3Procedure.h"
35	#include "B3ValueInlines.h"	34	#include "B3ValueInlines.h"
36	#include <wtf/ListDump.h>	35	#include <wtf/ListDump.h>
Lines 52-63 BasicBlock::~BasicBlock() Source/JavaScriptCore/b3/B3BasicBlock.cpp_sec2
52	void BasicBlock::append(Value* value)	51	void BasicBlock::append(Value* value)
53	{	52	{
54	m_values.append(value);	53	m_values.append(value);
		54	value->owner = this;
55	}	55	}
56		56
57	void BasicBlock::appendNonTerminal(Value* value)	57	void BasicBlock::appendNonTerminal(Value* value)
58	{	58	{
59	m_values.append(m_values.last());	59	m_values.append(m_values.last());
60	m_values[m_values.size() - 1] = value;	60	m_values[m_values.size() - 1] = value;
		61	value->owner = this;
61	}	62	}
62		63
63	void BasicBlock::removeLast(Procedure& proc)	64	void BasicBlock::removeLast(Procedure& proc)
Lines 84-92 Value* BasicBlock::appendIntConstant(Pro Source/JavaScriptCore/b3/B3BasicBlock.cpp_sec3
84	return appendIntConstant(proc, likeValue->origin(), likeValue->type(), value);	85	return appendIntConstant(proc, likeValue->origin(), likeValue->type(), value);
85	}	86	}
86		87
		88	void BasicBlock::clearSuccessors()
		89	{
		90	m_successors.clear();
		91	}
		92
		93	void BasicBlock::appendSuccessor(const FrequentedBlock& target)
		94	{
		95	m_successors.append(target);
		96	}
		97
		98	void BasicBlock::setSuccessors(const FrequentedBlock& target)
		99	{
		100	m_successors.resize(1);
		101	m_successors[0] = target;
		102	}
		103
		104	void BasicBlock::setSuccessors(const FrequentedBlock& taken, const FrequentedBlock& notTaken)
		105	{
		106	m_successors.resize(2);
		107	m_successors[0] = taken;
		108	m_successors[1] = notTaken;
		109	}
		110
87	bool BasicBlock::replaceSuccessor(BasicBlock* from, BasicBlock* to)	111	bool BasicBlock::replaceSuccessor(BasicBlock* from, BasicBlock* to)
88	{	112	{
89	return last()->as<ControlValue>()->replaceSuccessor(from, to);	113	bool result = false;
		114	for (BasicBlock*& successor : successorBlocks()) {
		115	if (successor == from) {
		116	successor = to;
		117	result = true;
		118
		119	// Keep looping because a successor may be mentioned multiple times, like in a Switch.
		120	}
		121	}
		122	return result;
90	}	123	}
91		124
92	bool BasicBlock::addPredecessor(BasicBlock* block)	125	bool BasicBlock::addPredecessor(BasicBlock* block)
Lines 121-126 void BasicBlock::deepDump(const Procedur Source/JavaScriptCore/b3/B3BasicBlock.cpp_sec4
121	out.print(" Predecessors: ", pointerListDump(predecessors()), "\n");	154	out.print(" Predecessors: ", pointerListDump(predecessors()), "\n");
122	for (Value* value : *this)	155	for (Value* value : *this)
123	out.print(" ", B3::deepDump(proc, value), "\n");	156	out.print(" ", B3::deepDump(proc, value), "\n");
		157	if (successors().size()) {
		158	out.print(" Successors: ");
		159	if (size())
		160	last()->dumpSuccessors(this, out);
		161	else
		162	out.print(listDump(successors()));
		163	out.print("\n");
		164	}
		165	}
		166
		167	Value* BasicBlock::appendNewControlValue(Procedure& proc, Opcode opcode, Origin origin)
		168	{
		169	RELEASE_ASSERT(opcode == Oops);
		170	clearSuccessors();
		171	return appendNew<Value>(proc, opcode, origin);
		172	}
		173
		174	Value* BasicBlock::appendNewControlValue(Procedure& proc, Opcode opcode, Origin origin, Value* value)
		175	{
		176	RELEASE_ASSERT(opcode == Return);
		177	clearSuccessors();
		178	return appendNew<Value>(proc, opcode, origin, value);
		179	}
		180
		181	Value* BasicBlock::appendNewControlValue(Procedure& proc, Opcode opcode, Origin origin, const FrequentedBlock& target)
		182	{
		183	RELEASE_ASSERT(opcode == Jump);
		184	setSuccessors(target);
		185	return appendNew<Value>(proc, opcode, origin);
		186	}
		187
		188	Value* BasicBlock::appendNewControlValue(Procedure& proc, Opcode opcode, Origin origin, Value* predicate, const FrequentedBlock& taken, const FrequentedBlock& notTaken)
		189	{
		190	RELEASE_ASSERT(opcode == Branch);
		191	setSuccessors(taken, notTaken);
		192	return appendNew<Value>(proc, opcode, origin, predicate);
124	}	193	}
125		194
126	} } // namespace JSC::B3	195	} } // namespace JSC::B3

Lines 29-36 Source/JavaScriptCore/b3/B3BasicBlockInlines.h_sec1
- Source/JavaScriptCore/b3/B3BasicBlockInlines.h -28 / +19 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3BasicBlock.h"	31	#include "B3BasicBlock.h"
32	#include "B3ControlValue.h"
33	#include "B3ProcedureInlines.h"	32	#include "B3ProcedureInlines.h"
		33	#include "B3Value.h"
34		34
35	namespace JSC { namespace B3 {	35	namespace JSC { namespace B3 {
36		36
Lines 58-106 ValueType* BasicBlock::replaceLastWithNe Source/JavaScriptCore/b3/B3BasicBlockInlines.h_sec2
58	return result;	58	return result;
59	}	59	}
60		60
61	inline unsigned BasicBlock::numSuccessors() const	61	inline const FrequentedBlock& BasicBlock::taken() const
62	{	62	{
63	return last()->as<ControlValue>()->numSuccessors();	63	ASSERT(last()->opcode() == Jump \|\| last()->opcode() == Branch);
		64	return m_successors[0];
64	}	65	}
65		66
66	inline const FrequentedBlock& BasicBlock::successor(unsigned index) const	67	inline FrequentedBlock& BasicBlock::taken()
67	{	68	{
68	return last()->as<ControlValue>()->successor(index);	69	ASSERT(last()->opcode() == Jump \|\| last()->opcode() == Branch);
		70	return m_successors[0];
69	}	71	}
70		72
71	inline FrequentedBlock& BasicBlock::successor(unsigned index)	73	inline const FrequentedBlock& BasicBlock::notTaken() const
72	{	74	{
73	return last()->as<ControlValue>()->successor(index);	75	ASSERT(last()->opcode() == Branch);
		76	return m_successors[1];
74	}	77	}
75		78
76	inline const BasicBlock::SuccessorList& BasicBlock::successors() const	79	inline FrequentedBlock& BasicBlock::notTaken()
77	{	80	{
78	return last()->as<ControlValue>()->successors();	81	ASSERT(last()->opcode() == Branch);
		82	return m_successors[1];
79	}	83	}
80		84
81	inline BasicBlock::SuccessorList& BasicBlock::successors()	85	inline const FrequentedBlock& BasicBlock::fallThrough() const
82	{	86	{
83	return last()->as<ControlValue>()->successors();	87	ASSERT(last()->opcode() == Branch \|\| last()->opcode() == Switch);
		88	return m_successors.last();
84	}	89	}
85		90
86	inline BasicBlock* BasicBlock::successorBlock(unsigned index) const	91	inline FrequentedBlock& BasicBlock::fallThrough()
87	{	92	{
88	return successor(index).block();	93	ASSERT(last()->opcode() == Branch \|\| last()->opcode() == Switch);
89	}	94	return m_successors.last();
90
91	inline BasicBlock*& BasicBlock::successorBlock(unsigned index)
92	{
93	return successor(index).block();
94	}
95
96	inline SuccessorCollection<BasicBlock, BasicBlock::SuccessorList> BasicBlock::successorBlocks()
97	{
98	return SuccessorCollection<BasicBlock, SuccessorList>(successors());
99	}
100
101	inline SuccessorCollection<const BasicBlock, const BasicBlock::SuccessorList> BasicBlock::successorBlocks() const
102	{
103	return SuccessorCollection<const BasicBlock, const SuccessorList>(successors());
104	}	95	}
105		96
106	} } // namespace JSC::B3	97	} } // namespace JSC::B3

Lines 78-85 BasicBlock* BlockInsertionSet::splitForw Source/JavaScriptCore/b3/B3BlockInsertionSet.cpp_sec1
- Source/JavaScriptCore/b3/B3BlockInsertionSet.cpp -2 / +2 lines
78	result->m_values[i] = block->m_values[i];	78	result->m_values[i] = block->m_values[i];
79		79
80	// Make the new block jump to 'block'.	80	// Make the new block jump to 'block'.
81	result->m_values[valueIndex] =	81	result->m_values[valueIndex] = m_proc.add<Value>(Jump, value->origin());
82	m_proc.add<ControlValue>(Jump, value->origin(), FrequentedBlock(block));	82	result->setSuccessors(FrequentedBlock(block));
83		83
84	// If we had inserted things into 'block' before this, execute those insertions now.	84	// If we had inserted things into 'block' before this, execute those insertions now.
85	if (insertionSet)	85	if (insertionSet)

Lines 30-36 Source/JavaScriptCore/b3/B3BreakCriticalEdges.cpp_sec1
- Source/JavaScriptCore/b3/B3BreakCriticalEdges.cpp -3 / +2 lines
30		30
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3BlockInsertionSet.h"	32	#include "B3BlockInsertionSet.h"
33	#include "B3ControlValue.h"
34	#include "B3ProcedureInlines.h"	33	#include "B3ProcedureInlines.h"
35	#include "B3ValueInlines.h"	34	#include "B3ValueInlines.h"
36		35
Lines 50-57 void breakCriticalEdges(Procedure& proc) Source/JavaScriptCore/b3/B3BreakCriticalEdges.cpp_sec2
50		49
51	BasicBlock* pad =	50	BasicBlock* pad =
52	insertionSet.insertBefore(successor, successor->frequency());	51	insertionSet.insertBefore(successor, successor->frequency());
53	pad->appendNew<ControlValue>(	52	pad->appendNew<Value>(proc, Jump, successor->at(0)->origin());
54	proc, Jump, successor->at(0)->origin(), FrequentedBlock(successor));	53	pad->setSuccessors(FrequentedBlock(successor));
55	pad->addPredecessor(block);	54	pad->addPredecessor(block);
56	successor->replacePredecessor(block, pad);	55	successor->replacePredecessor(block, pad);
57	successor = pad;	56	successor = pad;

Line 0 Source/JavaScriptCore/b3/B3CaseCollection.cpp_sec1
- Source/JavaScriptCore/b3/B3CaseCollection.cpp +48 lines
	1	/*
	2	* Copyright (C) 2016 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 "B3CaseCollection.h"
	28
	29	#if ENABLE(B3_JIT)
	30
	31	#include "B3BasicBlockInlines.h"
	32	#include "B3CaseCollectionInlines.h"
	33	#include <wtf/CommaPrinter.h>
	34
	35	namespace JSC { namespace B3 {
	36
	37	void CaseCollection::dump(PrintStream& out) const
	38	{
	39	CommaPrinter comma;
	40	for (SwitchCase switchCase : *this)
	41	out.print(comma, switchCase);
	42	out.print(comma, "default->", fallThrough());
	43	}
	44
	45	} } // namespace JSC::B3
	46
	47	#endif // ENABLE(B3_JIT)
	48

Lines 84-90 CheckSpecial::CheckSpecial(Air::Opcode o Source/JavaScriptCore/b3/B3CheckSpecial.cpp_sec1
- Source/JavaScriptCore/b3/B3CheckSpecial.cpp -1 / +2 lines
84	, m_stackmapRole(stackmapRole)	84	, m_stackmapRole(stackmapRole)
85	, m_numCheckArgs(numArgs)	85	, m_numCheckArgs(numArgs)
86	{	86	{
87	ASSERT(isTerminal(opcode));	87	ASSERT(isDefinitelyTerminal(opcode));
88	}	88	}
89		89
90	CheckSpecial::CheckSpecial(const CheckSpecial::Key& key)	90	CheckSpecial::CheckSpecial(const CheckSpecial::Key& key)
Lines 102-107 Inst CheckSpecial::hiddenBranch(const In Source/JavaScriptCore/b3/B3CheckSpecial.cpp_sec2
102	hiddenBranch.args.reserveInitialCapacity(m_numCheckArgs);	102	hiddenBranch.args.reserveInitialCapacity(m_numCheckArgs);
103	for (unsigned i = 0; i < m_numCheckArgs; ++i)	103	for (unsigned i = 0; i < m_numCheckArgs; ++i)
104	hiddenBranch.args.append(inst.args[i + 1]);	104	hiddenBranch.args.append(inst.args[i + 1]);
		105	ASSERT(hiddenBranch.isTerminal());
105	return hiddenBranch;	106	return hiddenBranch;
106	}	107	}
107		108

Lines 1-95 Source/JavaScriptCore/b3/B3ControlValue.cpp_sec1
- Source/JavaScriptCore/b3/B3ControlValue.cpp -95 lines
1	/*
2	* Copyright (C) 2015-2016 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 "B3ControlValue.h"
28
29	#if ENABLE(B3_JIT)
30
31	#include "B3BasicBlock.h"
32
33	namespace JSC { namespace B3 {
34
35	ControlValue::~ControlValue()
36	{
37	}
38
39	bool ControlValue::replaceSuccessor(BasicBlock* from, BasicBlock* to)
40	{
41	bool result = false;
42	for (FrequentedBlock& successor : m_successors) {
43	if (successor.block() == from) {
44	successor.block() = to;
45	result = true;
46
47	// Keep looping because it's valid for a successor to be mentioned multiple times,
48	// like if multiple switch cases have the same target.
49	}
50	}
51	return result;
52	}
53
54	void ControlValue::convertToJump(BasicBlock* destination)
55	{
56	unsigned index = this->index();
57	Origin origin = this->origin();
58	BasicBlock* owner = this->owner;
59
60	this->~ControlValue();
61
62	new (this) ControlValue(Jump, origin, FrequentedBlock(destination));
63
64	this->owner = owner;
65	this->m_index = index;
66	}
67
68	void ControlValue::convertToOops()
69	{
70	unsigned index = this->index();
71	Origin origin = this->origin();
72	BasicBlock* owner = this->owner;
73
74	this->~ControlValue();
75
76	new (this) ControlValue(Oops, origin);
77
78	this->owner = owner;
79	this->m_index = index;
80	}
81
82	void ControlValue::dumpMeta(CommaPrinter& comma, PrintStream& out) const
83	{
84	for (FrequentedBlock successor : m_successors)
85	out.print(comma, successor);
86	}
87
88	Value* ControlValue::cloneImpl() const
89	{
90	return new ControlValue(*this);
91	}
92
93	} } // namespace JSC::B3
94
95	#endif // ENABLE(B3_JIT)

Lines 1-5 Source/JavaScriptCore/b3/B3DataSection.cpp_sec1
- Source/JavaScriptCore/b3/B3DataSection.cpp -2 / +2 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 31-37 Source/JavaScriptCore/b3/B3DataSection.cpp_sec2
31	namespace JSC { namespace B3 {	31	namespace JSC { namespace B3 {
32		32
33	DataSection::DataSection(size_t size)	33	DataSection::DataSection(size_t size)
34	: m_data(fastMalloc(size))	34	: m_data(fastZeroedMalloc(size))
35	, m_size(size)	35	, m_size(size)
36	{	36	{
37	}	37	}

Lines 30-36 Source/JavaScriptCore/b3/B3DuplicateTails.cpp_sec1
- Source/JavaScriptCore/b3/B3DuplicateTails.cpp -6 / +6 lines
30		30
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3BreakCriticalEdges.h"	32	#include "B3BreakCriticalEdges.h"
33	#include "B3ControlValue.h"
34	#include "B3Dominators.h"	33	#include "B3Dominators.h"
35	#include "B3FixSSA.h"	34	#include "B3FixSSA.h"
36	#include "B3IndexSet.h"	35	#include "B3IndexSet.h"
Lines 72-80 public: Source/JavaScriptCore/b3/B3DuplicateTails.cpp_sec2
72	IndexSet<BasicBlock> candidates;	71	IndexSet<BasicBlock> candidates;
73		72
74	for (BasicBlock* block : m_proc) {	73	for (BasicBlock* block : m_proc) {
75	if (block->size() > m_maxSize \|\| block->numSuccessors() > m_maxSuccessors)	74	if (block->size() > m_maxSize
		75	\|\| block->numSuccessors() > m_maxSuccessors)
76	continue;	76	continue;
77		77
78	candidates.add(block);	78	candidates.add(block);
79	}	79	}
80		80
Lines 97-107 public: Source/JavaScriptCore/b3/B3DuplicateTails.cpp_sec3
97	}	97	}
98		98
99	for (BasicBlock* block : m_proc) {	99	for (BasicBlock* block : m_proc) {
100	ControlValue* jump = block->last()->as<ControlValue>();	100	if (block->last()->opcode() != Jump)
101	if (jump->opcode() != Jump)
102	continue;	101	continue;
103		102
104	BasicBlock* tail = jump->successorBlock(0);	103	BasicBlock* tail = block->successorBlock(0);
105	if (!candidates.contains(tail))	104	if (!candidates.contains(tail))
106	continue;	105	continue;
107		106
Lines 130-135 public: Source/JavaScriptCore/b3/B3DuplicateTails.cpp_sec4
130	map.add(value, clone);	129	map.add(value, clone);
131	block->append(clone);	130	block->append(clone);
132	}	131	}
		132	block->successors() = tail->successors();
133	}	133	}
134		134
135	m_proc.resetReachability();	135	m_proc.resetReachability();

Lines 29-35 Source/JavaScriptCore/b3/B3FoldPathConstants.cpp_sec1
- Source/JavaScriptCore/b3/B3FoldPathConstants.cpp -10 / +9 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3ControlValue.h"	32	#include "B3CaseCollectionInlines.h"
33	#include "B3Dominators.h"	33	#include "B3Dominators.h"
34	#include "B3InsertionSetInlines.h"	34	#include "B3InsertionSetInlines.h"
35	#include "B3PhaseScope.h"	35	#include "B3PhaseScope.h"
Lines 87-110 public: Source/JavaScriptCore/b3/B3FoldPathConstants.cpp_sec2
87	};	87	};
88		88
89	for (BasicBlock* block : m_proc) {	89	for (BasicBlock* block : m_proc) {
90	ControlValue* branch = block->last()->as<ControlValue>();	90	Value* branch = block->last();
91	switch (branch->opcode()) {	91	switch (branch->opcode()) {
92	case Branch:	92	case Branch:
93	if (branch->successorBlock(0) == branch->successorBlock(1))	93	if (block->successorBlock(0) == block->successorBlock(1))
94	continue;	94	continue;
95	addOverride(	95	addOverride(
96	block, branch->child(0),	96	block, branch->child(0),
97	Override::nonZero(branch->successorBlock(0)));	97	Override::nonZero(block->successorBlock(0)));
98	addOverride(	98	addOverride(
99	block, branch->child(0),	99	block, branch->child(0),
100	Override::constant(branch->successorBlock(1), 0));	100	Override::constant(block->successorBlock(1), 0));
101	break;	101	break;
102	case Switch: {	102	case Switch: {
103	HashMap<BasicBlock*, unsigned> targetUses;	103	HashMap<BasicBlock*, unsigned> targetUses;
104	for (const SwitchCase& switchCase : *branch->as<SwitchValue>())	104	for (const SwitchCase& switchCase : branch->as<SwitchValue>()->cases(block))
105	targetUses.add(switchCase.targetBlock(), 0).iterator->value++;	105	targetUses.add(switchCase.targetBlock(), 0).iterator->value++;
106		106
107	for (const SwitchCase& switchCase : *branch->as<SwitchValue>()) {	107	for (const SwitchCase& switchCase : branch->as<SwitchValue>()->cases(block)) {
108	if (targetUses.find(switchCase.targetBlock())->value != 1)	108	if (targetUses.find(switchCase.targetBlock())->value != 1)
109	continue;	109	continue;
110		110
Lines 158-166 public: Source/JavaScriptCore/b3/B3FoldPathConstants.cpp_sec3
158		158
159	switch (value->opcode()) {	159	switch (value->opcode()) {
160	case Branch: {	160	case Branch: {
161	ControlValue* branch = value->as<ControlValue>();	161	if (getOverride(block, value->child(0)).isNonZero) {
162	if (getOverride(block, branch->child(0)).isNonZero) {	162	value->replaceWithJump(block, block->taken());
163	branch->convertToJump(branch->taken().block());
164	changed = true;	163	changed = true;
165	}	164	}
166	break;	165	break;

Lines 155-161 public: Source/JavaScriptCore/b3/B3LowerToAir.cpp_sec1
- Source/JavaScriptCore/b3/B3LowerToAir.cpp -2 / +1 lines
155	}	155	}
156		156
157	// Make sure that the successors are set up correctly.	157	// Make sure that the successors are set up correctly.
158	ASSERT(block->successors().size() <= 2);
159	for (B3::FrequentedBlock successor : block->successors()) {	158	for (B3::FrequentedBlock successor : block->successors()) {
160	m_blockToBlock[block]->successors().append(	159	m_blockToBlock[block]->successors().append(
161	Air::FrequentedBlock(m_blockToBlock[successor.block()], successor.frequency()));	160	Air::FrequentedBlock(m_blockToBlock[successor.block()], successor.frequency()));
Lines 2441-2447 private: Source/JavaScriptCore/b3/B3LowerToAir.cpp_sec2
2441	}	2440	}
2442	return;	2441	return;
2443	}	2442	}
2444		2443
2445	case B3::Oops: {	2444	case B3::Oops: {
2446	append(Air::Oops);	2445	append(Air::Oops);
2447	return;	2446	return;

Lines 1-5 Source/JavaScriptCore/b3/B3MathExtras.cpp_sec1
- Source/JavaScriptCore/b3/B3MathExtras.cpp -17 / +13 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 33-39 Source/JavaScriptCore/b3/B3MathExtras.cpp_sec2
33	#include "B3Const32Value.h"	33	#include "B3Const32Value.h"
34	#include "B3ConstDoubleValue.h"	34	#include "B3ConstDoubleValue.h"
35	#include "B3ConstPtrValue.h"	35	#include "B3ConstPtrValue.h"
36	#include "B3ControlValue.h"
37	#include "B3UpsilonValue.h"	36	#include "B3UpsilonValue.h"
38	#include "B3ValueInlines.h"	37	#include "B3ValueInlines.h"
39	#include "MathCommon.h"	38	#include "MathCommon.h"
Lines 52-61 std::pair<BasicBlock, Value> powDouble Source/JavaScriptCore/b3/B3MathExtras.cpp_sec3
52	Value* shouldGoSlowPath = start->appendNew<Value>(procedure, Above, origin,	51	Value* shouldGoSlowPath = start->appendNew<Value>(procedure, Above, origin,
53	y,	52	y,
54	start->appendNew<Const32Value>(procedure, origin, maxExponentForIntegerMathPow));	53	start->appendNew<Const32Value>(procedure, origin, maxExponentForIntegerMathPow));
55	start->appendNew<ControlValue>(	54	start->appendNew<Value>(procedure, Branch, origin, shouldGoSlowPath);
56	procedure, Branch, origin,	55	start->setSuccessors(FrequentedBlock(functionCallCase), FrequentedBlock(loopPreHeaderCase));
57	shouldGoSlowPath,
58	FrequentedBlock(functionCallCase), FrequentedBlock(loopPreHeaderCase));
59		56
60	// Function call.	57	// Function call.
61	Value* yAsDouble = functionCallCase->appendNew<Value>(procedure, IToD, origin, y);	58	Value* yAsDouble = functionCallCase->appendNew<Value>(procedure, IToD, origin, y);
Lines 65-71 std::pair<BasicBlock, Value> powDouble Source/JavaScriptCore/b3/B3MathExtras.cpp_sec4
65	functionCallCase->appendNew<ConstPtrValue>(procedure, origin, bitwise_cast<void*>(powDouble)),	62	functionCallCase->appendNew<ConstPtrValue>(procedure, origin, bitwise_cast<void*>(powDouble)),
66	x, yAsDouble);	63	x, yAsDouble);
67	UpsilonValue* powResultUpsilon = functionCallCase->appendNew<UpsilonValue>(procedure, origin, powResult);	64	UpsilonValue* powResultUpsilon = functionCallCase->appendNew<UpsilonValue>(procedure, origin, powResult);
68	functionCallCase->appendNew<ControlValue>(procedure, Jump, origin, FrequentedBlock(continuation));	65	functionCallCase->appendNew<Value>(procedure, Jump, origin);
		66	functionCallCase->setSuccessors(FrequentedBlock(continuation));
69		67
70	// Loop pre-header.	68	// Loop pre-header.
71	Value* initialResult = loopPreHeaderCase->appendNew<ConstDoubleValue>(procedure, origin, 1.);	69	Value* initialResult = loopPreHeaderCase->appendNew<ConstDoubleValue>(procedure, origin, 1.);
Lines 73-79 std::pair<BasicBlock, Value> powDouble Source/JavaScriptCore/b3/B3MathExtras.cpp_sec5
73	UpsilonValue* initialResultValue = loopPreHeaderCase->appendNew<UpsilonValue>(procedure, origin, initialResult);	71	UpsilonValue* initialResultValue = loopPreHeaderCase->appendNew<UpsilonValue>(procedure, origin, initialResult);
74	UpsilonValue* initialSquaredInput = loopPreHeaderCase->appendNew<UpsilonValue>(procedure, origin, x);	72	UpsilonValue* initialSquaredInput = loopPreHeaderCase->appendNew<UpsilonValue>(procedure, origin, x);
75	UpsilonValue* initialLoopCounter = loopPreHeaderCase->appendNew<UpsilonValue>(procedure, origin, y);	73	UpsilonValue* initialLoopCounter = loopPreHeaderCase->appendNew<UpsilonValue>(procedure, origin, y);
76	loopPreHeaderCase->appendNew<ControlValue>(procedure, Jump, origin, FrequentedBlock(loopTestForEvenCase));	74	loopPreHeaderCase->appendNew<Value>(procedure, Jump, origin);
		75	loopPreHeaderCase->setSuccessors(FrequentedBlock(loopTestForEvenCase));
77		76
78	// Test if what is left of the counter is even.	77	// Test if what is left of the counter is even.
79	Value* inLoopCounter = loopTestForEvenCase->appendNew<Value>(procedure, Phi, Int32, origin);	78	Value* inLoopCounter = loopTestForEvenCase->appendNew<Value>(procedure, Phi, Int32, origin);
Lines 81-90 std::pair<BasicBlock, Value> powDouble Source/JavaScriptCore/b3/B3MathExtras.cpp_sec6
81	Value* lastCounterBit = loopTestForEvenCase->appendNew<Value>(procedure, BitAnd, origin,	80	Value* lastCounterBit = loopTestForEvenCase->appendNew<Value>(procedure, BitAnd, origin,
82	inLoopCounter,	81	inLoopCounter,
83	loopTestForEvenCase->appendNew<Const32Value>(procedure, origin, 1));	82	loopTestForEvenCase->appendNew<Const32Value>(procedure, origin, 1));
84	loopTestForEvenCase->appendNew<ControlValue>(	83	loopTestForEvenCase->appendNew<Value>(procedure, Branch, origin, lastCounterBit);
85	procedure, Branch, origin,	84	loopTestForEvenCase->setSuccessors(FrequentedBlock(loopOdd), FrequentedBlock(loopEvenOdd));
86	lastCounterBit,
87	FrequentedBlock(loopOdd), FrequentedBlock(loopEvenOdd));
88		85
89	// Counter is odd.	86	// Counter is odd.
90	Value* inLoopResult = loopOdd->appendNew<Value>(procedure, Phi, Double, origin);	87	Value* inLoopResult = loopOdd->appendNew<Value>(procedure, Phi, Double, origin);
Lines 94-100 std::pair<BasicBlock, Value> powDouble Source/JavaScriptCore/b3/B3MathExtras.cpp_sec7
94	updatedLoopResultUpsilon->setPhi(inLoopResult);	91	updatedLoopResultUpsilon->setPhi(inLoopResult);
95	UpsilonValue* updatedLoopResult = loopOdd->appendNew<UpsilonValue>(procedure, origin, updatedResult);	92	UpsilonValue* updatedLoopResult = loopOdd->appendNew<UpsilonValue>(procedure, origin, updatedResult);
96		93
97	loopOdd->appendNew<ControlValue>(procedure, Jump, origin, FrequentedBlock(loopEvenOdd));	94	loopOdd->appendNew<Value>(procedure, Jump, origin);
		95	loopOdd->setSuccessors(FrequentedBlock(loopEvenOdd));
98		96
99	// Even value and following the Odd.	97	// Even value and following the Odd.
100	Value* squaredInput = loopEvenOdd->appendNew<Value>(procedure, Mul, origin, inLoopSquaredInput, inLoopSquaredInput);	98	Value* squaredInput = loopEvenOdd->appendNew<Value>(procedure, Mul, origin, inLoopSquaredInput, inLoopSquaredInput);
Lines 109-118 std::pair<BasicBlock, Value> powDouble Source/JavaScriptCore/b3/B3MathExtras.cpp_sec8
109	initialLoopCounter->setPhi(inLoopCounter);	107	initialLoopCounter->setPhi(inLoopCounter);
110	updatedCounterUpsilon->setPhi(inLoopCounter);	108	updatedCounterUpsilon->setPhi(inLoopCounter);
111		109
112	loopEvenOdd->appendNew<ControlValue>(	110	loopEvenOdd->appendNew<Value>(procedure, Branch, origin, updatedCounter);
113	procedure, Branch, origin,	111	loopEvenOdd->setSuccessors(FrequentedBlock(loopTestForEvenCase), FrequentedBlock(continuation));
114	updatedCounter,
115	FrequentedBlock(loopTestForEvenCase), FrequentedBlock(continuation));
116		112
117	// Inline loop.	113	// Inline loop.
118	Value* finalResultPhi = continuation->appendNew<Value>(procedure, Phi, Double, origin);	114	Value* finalResultPhi = continuation->appendNew<Value>(procedure, Phi, Double, origin);

Lines 207-227 enum Opcode : int16_t { Source/JavaScriptCore/b3/B3Opcode.h_sec1
- Source/JavaScriptCore/b3/B3Opcode.h -6 / +20 lines
207	Upsilon, // This uses the UpsilonValue class.	207	Upsilon, // This uses the UpsilonValue class.
208	Phi,	208	Phi,
209		209
210	// Jump. Uses the ControlValue class.	210	// Jump.
211	Jump,	211	Jump,
212		212
213	// Polymorphic branch, usable with any integer type. Branches if not equal to zero. Uses the	213	// Polymorphic branch, usable with any integer type. Branches if not equal to zero. The 0-index
214	// ControlValue class, with the 0-index successor being the true successor.	214	// successor is the true successor.
215	Branch,	215	Branch,
216		216
217	// Switch. Switches over either Int32 or Int64. Uses the SwitchValue class.	217	// Switch. Switches over either Int32 or Int64. Uses the SwitchValue class.
218	Switch,	218	Switch,
219		219
220	// Return. Note that B3 procedures don't know their return type, so this can just return any	220	// Return. Note that B3 procedures don't know their return type, so this can just return any
221	// type. Uses the ControlValue class.	221	// type.
222	Return,	222	Return,
223		223
224	// This is a terminal that indicates that we will never get here. Uses the ControlValue class.	224	// This is a terminal that indicates that we will never get here.
225	Oops	225	Oops
226	};	226	};
227		227
Lines 259-264 inline bool isConstant(Opcode opcode) Source/JavaScriptCore/b3/B3Opcode.h_sec2
259	}	259	}
260	}	260	}
261		261
		262	inline bool isDefinitelyTerminal(Opcode opcode)
		263	{
		264	switch (opcode) {
		265	case Jump:
		266	case Branch:
		267	case Switch:
		268	case Oops:
		269	case Return:
		270	return true;
		271	default:
		272	return false;
		273	}
		274	}
		275
262	} } // namespace JSC::B3	276	} } // namespace JSC::B3
263		277
264	namespace WTF {	278	namespace WTF {

Lines 148-178 void Procedure::resetValueOwners() Source/JavaScriptCore/b3/B3Procedure.cpp_sec1
- Source/JavaScriptCore/b3/B3Procedure.cpp -25 lines
148		148
149	void Procedure::resetReachability()	149	void Procedure::resetReachability()
150	{	150	{
151	if (shouldValidateIR()) {
152	// Validate the basic properties that we need for resetting reachability. We often reset
153	// reachability before IR validation, so without this mini-validation, you would crash inside
154	// B3::resetReachability() without getting any IR dump.
155
156	BasicBlock* badBlock = nullptr;
157	for (BasicBlock* block : *this) {
158	if (!block->size()) {
159	badBlock = block;
160	break;
161	}
162
163	if (!block->last()->as<ControlValue>()) {
164	badBlock = block;
165	break;
166	}
167	}
168
169	if (badBlock) {
170	dataLog("FATAL: Invalid basic block ", *badBlock, " while running Procedure::resetReachability().\n");
171	dataLog(*this);
172	RELEASE_ASSERT_NOT_REACHED();
173	}
174	}
175
176	recomputePredecessors(m_blocks);	151	recomputePredecessors(m_blocks);
177		152
178	// The common case is that this does not find any dead blocks.	153	// The common case is that this does not find any dead blocks.

Lines 31-37 Source/JavaScriptCore/b3/B3ReduceStrength.cpp_sec1
- Source/JavaScriptCore/b3/B3ReduceStrength.cpp -35 / +34 lines
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3BlockInsertionSet.h"	32	#include "B3BlockInsertionSet.h"
33	#include "B3ComputeDivisionMagic.h"	33	#include "B3ComputeDivisionMagic.h"
34	#include "B3ControlValue.h"
35	#include "B3Dominators.h"	34	#include "B3Dominators.h"
36	#include "B3IndexSet.h"	35	#include "B3IndexSet.h"
37	#include "B3InsertionSetInlines.h"	36	#include "B3InsertionSetInlines.h"
Lines 1717-1723 private: Source/JavaScriptCore/b3/B3ReduceStrength.cpp_sec2
1717	// Replace the rest of the block with an Oops.	1716	// Replace the rest of the block with an Oops.
1718	for (unsigned i = m_index + 1; i < m_block->size() - 1; ++i)	1717	for (unsigned i = m_index + 1; i < m_block->size() - 1; ++i)
1719	m_block->at(i)->replaceWithBottom(m_insertionSet, m_index);	1718	m_block->at(i)->replaceWithBottom(m_insertionSet, m_index);
1720	m_block->last()->as<ControlValue>()->convertToOops();	1719	m_block->last()->replaceWithOops(m_block);
1721	m_block->last()->setOrigin(checkValue->origin());	1720	m_block->last()->setOrigin(checkValue->origin());
1722		1721
1723	// Replace ourselves last.	1722	// Replace ourselves last.
Lines 1773-1778 private: Source/JavaScriptCore/b3/B3ReduceStrength.cpp_sec3
1773	return value->opcode() == Select	1772	return value->opcode() == Select
1774	&& (value->child(1)->isConstant() && value->child(2)->isConstant());	1773	&& (value->child(1)->isConstant() && value->child(2)->isConstant());
1775	});	1774	});
		1775
1776	if (select) {	1776	if (select) {
1777	specializeSelect(select);	1777	specializeSelect(select);
1778	break;	1778	break;
Lines 1781-1830 private: Source/JavaScriptCore/b3/B3ReduceStrength.cpp_sec4
1781	}	1781	}
1782		1782
1783	case Branch: {	1783	case Branch: {
1784	ControlValue* branch = m_value->as<ControlValue>();
1785
1786	// Turn this: Branch(NotEqual(x, 0))	1784	// Turn this: Branch(NotEqual(x, 0))
1787	// Into this: Branch(x)	1785	// Into this: Branch(x)
1788	if (branch->child(0)->opcode() == NotEqual && branch->child(0)->child(1)->isInt(0)) {	1786	if (m_value->child(0)->opcode() == NotEqual && m_value->child(0)->child(1)->isInt(0)) {
1789	branch->child(0) = branch->child(0)->child(0);	1787	m_value->child(0) = m_value->child(0)->child(0);
1790	m_changed = true;	1788	m_changed = true;
1791	}	1789	}
1792		1790
1793	// Turn this: Branch(Equal(x, 0), then, else)	1791	// Turn this: Branch(Equal(x, 0), then, else)
1794	// Into this: Branch(x, else, then)	1792	// Into this: Branch(x, else, then)
1795	if (branch->child(0)->opcode() == Equal && branch->child(0)->child(1)->isInt(0)) {	1793	if (m_value->child(0)->opcode() == Equal && m_value->child(0)->child(1)->isInt(0)) {
1796	branch->child(0) = branch->child(0)->child(0);	1794	m_value->child(0) = m_value->child(0)->child(0);
1797	std::swap(branch->taken(), branch->notTaken());	1795	std::swap(m_block->taken(), m_block->notTaken());
1798	m_changed = true;	1796	m_changed = true;
1799	}	1797	}
1800		1798
1801	// Turn this: Branch(BitXor(bool, 1), then, else)	1799	// Turn this: Branch(BitXor(bool, 1), then, else)
1802	// Into this: Branch(bool, else, then)	1800	// Into this: Branch(bool, else, then)
1803	if (branch->child(0)->opcode() == BitXor	1801	if (m_value->child(0)->opcode() == BitXor
1804	&& branch->child(0)->child(1)->isInt32(1)	1802	&& m_value->child(0)->child(1)->isInt32(1)
1805	&& branch->child(0)->child(0)->returnsBool()) {	1803	&& m_value->child(0)->child(0)->returnsBool()) {
1806	branch->child(0) = branch->child(0)->child(0);	1804	m_value->child(0) = m_value->child(0)->child(0);
1807	std::swap(branch->taken(), branch->notTaken());	1805	std::swap(m_block->taken(), m_block->notTaken());
1808	m_changed = true;	1806	m_changed = true;
1809	}	1807	}
1810		1808
1811	// Turn this: Branch(BitAnd(bool, xyb1), then, else)	1809	// Turn this: Branch(BitAnd(bool, xyb1), then, else)
1812	// Into this: Branch(bool, then, else)	1810	// Into this: Branch(bool, then, else)
1813	if (branch->child(0)->opcode() == BitAnd	1811	if (m_value->child(0)->opcode() == BitAnd
1814	&& branch->child(0)->child(1)->hasInt()	1812	&& m_value->child(0)->child(1)->hasInt()
1815	&& branch->child(0)->child(1)->asInt() & 1	1813	&& m_value->child(0)->child(1)->asInt() & 1
1816	&& branch->child(0)->child(0)->returnsBool()) {	1814	&& m_value->child(0)->child(0)->returnsBool()) {
1817	branch->child(0) = branch->child(0)->child(0);	1815	m_value->child(0) = m_value->child(0)->child(0);
1818	m_changed = true;	1816	m_changed = true;
1819	}	1817	}
1820		1818
1821	TriState triState = branch->child(0)->asTriState();	1819	TriState triState = m_value->child(0)->asTriState();
1822		1820
1823	// Turn this: Branch(0, then, else)	1821	// Turn this: Branch(0, then, else)
1824	// Into this: Jump(else)	1822	// Into this: Jump(else)
1825	if (triState == FalseTriState) {	1823	if (triState == FalseTriState) {
1826	branch->taken().block()->removePredecessor(m_block);	1824	m_block->taken().block()->removePredecessor(m_block);
1827	branch->convertToJump(branch->notTaken().block());	1825	m_value->replaceWithJump(m_block, m_block->notTaken());
1828	m_changedCFG = true;	1826	m_changedCFG = true;
1829	break;	1827	break;
1830	}	1828	}
Lines 1832-1839 private: Source/JavaScriptCore/b3/B3ReduceStrength.cpp_sec5
1832	// Turn this: Branch(not 0, then, else)	1830	// Turn this: Branch(not 0, then, else)
1833	// Into this: Jump(then)	1831	// Into this: Jump(then)
1834	if (triState == TrueTriState) {	1832	if (triState == TrueTriState) {
1835	branch->notTaken().block()->removePredecessor(m_block);	1833	m_block->notTaken().block()->removePredecessor(m_block);
1836	branch->convertToJump(branch->taken().block());	1834	m_value->replaceWithJump(m_block, m_block->taken());
1837	m_changedCFG = true;	1835	m_changedCFG = true;
1838	break;	1836	break;
1839	}	1837	}
Lines 1842-1853 private: Source/JavaScriptCore/b3/B3ReduceStrength.cpp_sec6
1842	// of makes sense here because it's cheap, but hacks like this show that we're going	1840	// of makes sense here because it's cheap, but hacks like this show that we're going
1843	// to need SCCP.	1841	// to need SCCP.
1844	Value* check = m_pureCSE.findMatch(	1842	Value* check = m_pureCSE.findMatch(
1845	ValueKey(Check, Void, branch->child(0)), m_block, *m_dominators);	1843	ValueKey(Check, Void, m_value->child(0)), m_block, *m_dominators);
1846	if (check) {	1844	if (check) {
1847	// The Check would have side-exited if child(0) was non-zero. So, it must be	1845	// The Check would have side-exited if child(0) was non-zero. So, it must be
1848	// zero here.	1846	// zero here.
1849	branch->taken().block()->removePredecessor(m_block);	1847	m_block->taken().block()->removePredecessor(m_block);
1850	branch->convertToJump(branch->notTaken().block());	1848	m_value->replaceWithJump(m_block, m_block->notTaken());
1851	m_changedCFG = true;	1849	m_changedCFG = true;
1852	}	1850	}
1853	break;	1851	break;
Lines 1986-1998 private: Source/JavaScriptCore/b3/B3ReduceStrength.cpp_sec7
1986	// Remove the values from the predecessor.	1984	// Remove the values from the predecessor.
1987	predecessor->values().resize(startIndex);	1985	predecessor->values().resize(startIndex);
1988		1986
1989	predecessor->appendNew<ControlValue>(	1987	predecessor->appendNew<Value>(m_proc, Branch, source->origin(), predicate);
1990	m_proc, Branch, source->origin(), predicate,	1988	predecessor->setSuccessors(FrequentedBlock(cases[0]), FrequentedBlock(cases[1]));
1991	FrequentedBlock(cases[0]), FrequentedBlock(cases[1]));
1992		1989
1993	for (unsigned i = 0; i < numCases; ++i) {	1990	for (unsigned i = 0; i < numCases; ++i) {
1994	cases[i]->appendNew<ControlValue>(	1991	cases[i]->appendNew<Value>(m_proc, Jump, m_value->origin());
1995	m_proc, Jump, m_value->origin(), FrequentedBlock(m_block));	1992	cases[i]->setSuccessors(FrequentedBlock(m_block));
1996	}	1993	}
1997		1994
1998	m_changed = true;	1995	m_changed = true;
Lines 2221-2227 private: Source/JavaScriptCore/b3/B3ReduceStrength.cpp_sec8
2221	dataLog(	2218	dataLog(
2222	"Changing ", pointerDump(block), "'s terminal to a Jump.\n");	2219	"Changing ", pointerDump(block), "'s terminal to a Jump.\n");
2223	}	2220	}
2224	block->last()->as<ControlValue>()->convertToJump(firstSuccessor);	2221	block->last()->replaceWithJump(block, FrequentedBlock(firstSuccessor));
2225	m_changedCFG = true;	2222	m_changedCFG = true;
2226	}	2223	}
2227	}	2224	}
Lines 2239-2254 private: Source/JavaScriptCore/b3/B3ReduceStrength.cpp_sec9
2239	// Remove the terminal.	2236	// Remove the terminal.
2240	Value* value = block->values().takeLast();	2237	Value* value = block->values().takeLast();
2241	Origin jumpOrigin = value->origin();	2238	Origin jumpOrigin = value->origin();
2242	RELEASE_ASSERT(value->as<ControlValue>());	2239	RELEASE_ASSERT(value->effects().terminal);
2243	m_proc.deleteValue(value);	2240	m_proc.deleteValue(value);
2244		2241
2245	// Append the full contents of the successor to the predecessor.	2242	// Append the full contents of the successor to the predecessor.
2246	block->values().appendVector(successor->values());	2243	block->values().appendVector(successor->values());
		2244	block->successors() = successor->successors();
2247		2245
2248	// Make sure that the successor has nothing left in it. Make sure that the block	2246	// Make sure that the successor has nothing left in it. Make sure that the block
2249	// has a terminal so that nobody chokes when they look at it.	2247	// has a terminal so that nobody chokes when they look at it.
2250	successor->values().resize(0);	2248	successor->values().resize(0);
2251	successor->appendNew<ControlValue>(m_proc, Oops, jumpOrigin);	2249	successor->appendNew<Value>(m_proc, Oops, jumpOrigin);
		2250	successor->clearSuccessors();
2252		2251
2253	// Ensure that predecessors of block's new successors know what's up.	2252	// Ensure that predecessors of block's new successors know what's up.
2254	for (BasicBlock* newSuccessor : block->successorBlocks())	2253	for (BasicBlock* newSuccessor : block->successorBlocks())

Lines 37-66 SwitchValue::~SwitchValue() Source/JavaScriptCore/b3/B3SwitchValue.cpp_sec1
- Source/JavaScriptCore/b3/B3SwitchValue.cpp -14 / +59 lines
37	{	37	{
38	}	38	}
39		39
40	SwitchCase SwitchValue::removeCase(unsigned index)	40	SwitchCase SwitchValue::removeCase(BasicBlock* block, unsigned index)
41	{	41	{
42	FrequentedBlock resultBlock = m_successors[index];	42	FrequentedBlock resultBlock = block->successor(index);
43	int64_t resultValue = m_values[index];	43	int64_t resultValue = m_values[index];
44	m_successors[index] = m_successors.last();	44	block->successor(index) = block->successors().last();
45	m_successors.removeLast();	45	block->successors().removeLast();
46	m_values[index] = m_values.last();	46	m_values[index] = m_values.last();
47	m_values.removeLast();	47	m_values.removeLast();
48	return SwitchCase(resultValue, resultBlock);	48	return SwitchCase(resultValue, resultBlock);
49	}	49	}
50		50
51	void SwitchValue::appendCase(const SwitchCase& switchCase)	51	bool SwitchValue::hasFallThrough(const BasicBlock* block) const
		52	{
		53	unsigned numSuccessors = block->numSuccessors();
		54	unsigned numValues = m_values.size();
		55	RELEASE_ASSERT(numValues == numSuccessors \|\| numValues + 1 == numSuccessors);
		56
		57	return numValues + 1 == numSuccessors;
		58	}
		59
		60	bool SwitchValue::hasFallThrough() const
		61	{
		62	return hasFallThrough(owner);
		63	}
		64
		65	void SwitchValue::setFallThrough(BasicBlock* block, const FrequentedBlock& target)
		66	{
		67	if (!hasFallThrough())
		68	block->successors().append(target);
		69	else
		70	block->successors().last() = target;
		71	ASSERT(hasFallThrough(block));
		72	}
		73
		74	void SwitchValue::appendCase(BasicBlock* block, const SwitchCase& switchCase)
52	{	75	{
53	m_successors.append(m_successors.last());	76	if (!hasFallThrough())
54	m_successors[m_successors.size() - 2] = switchCase.target();	77	block->successors().append(switchCase.target());
		78	else {
		79	block->successors().append(block->successors().last());
		80	block->successor(block->numSuccessors() - 2) = switchCase.target();
		81	}
55	m_values.append(switchCase.caseValue());	82	m_values.append(switchCase.caseValue());
56	}	83	}
57		84
		85	void SwitchValue::setFallThrough(const FrequentedBlock& target)
		86	{
		87	setFallThrough(owner, target);
		88	}
		89
		90	void SwitchValue::appendCase(const SwitchCase& switchCase)
		91	{
		92	appendCase(owner, switchCase);
		93	}
		94
		95	void SwitchValue::dumpSuccessors(const BasicBlock* block, PrintStream& out) const
		96	{
		97	// We must not crash due to a number-of-successors mismatch! Someone debugging a
		98	// number-of-successors bug will want to dump IR!
		99	if (numCaseValues() + 1 != block->numSuccessors()) {
		100	Value::dumpSuccessors(block, out);
		101	return;
		102	}
		103
		104	out.print(cases(block));
		105	}
		106
58	void SwitchValue::dumpMeta(CommaPrinter& comma, PrintStream& out) const	107	void SwitchValue::dumpMeta(CommaPrinter& comma, PrintStream& out) const
59	{	108	{
60	// This destructively overrides ControlValue's dumpMeta().	109	out.print(comma, "cases = [", listDump(m_values), "]");
61	for (SwitchCase switchCase : *this)
62	out.print(comma, switchCase);
63	out.print(comma, "fallThrough = ", fallThrough());
64	}	110	}
65		111
66	Value* SwitchValue::cloneImpl() const	112	Value* SwitchValue::cloneImpl() const
Lines 68-77 Value* SwitchValue::cloneImpl() const Source/JavaScriptCore/b3/B3SwitchValue.cpp_sec2
68	return new SwitchValue(*this);	114	return new SwitchValue(*this);
69	}	115	}
70		116
71	SwitchValue::SwitchValue(Origin origin, Value* child, const FrequentedBlock& fallThrough)	117	SwitchValue::SwitchValue(Origin origin, Value* child)
72	: ControlValue(Switch, Void, origin, child)	118	: Value(CheckedOpcode, Switch, Void, origin, child)
73	{	119	{
74	m_successors.append(fallThrough);
75	}	120	}
76		121
77	} } // namespace JSC::B3	122	} } // namespace JSC::B3

Lines 35-40 Source/JavaScriptCore/b3/B3Validate.cpp_sec1
- Source/JavaScriptCore/b3/B3Validate.cpp -4 / +24 lines
35	#include "B3Procedure.h"	35	#include "B3Procedure.h"
36	#include "B3SlotBaseValue.h"	36	#include "B3SlotBaseValue.h"
37	#include "B3StackSlot.h"	37	#include "B3StackSlot.h"
		38	#include "B3SwitchValue.h"
38	#include "B3UpsilonValue.h"	39	#include "B3UpsilonValue.h"
39	#include "B3ValueInlines.h"	40	#include "B3ValueInlines.h"
40	#include "B3Variable.h"	41	#include "B3Variable.h"
Lines 107-114 public: Source/JavaScriptCore/b3/B3Validate.cpp_sec2
107	for (BasicBlock* block : blocks) {	108	for (BasicBlock* block : blocks) {
108	VALIDATE(block->size() >= 1, ("At ", *block));	109	VALIDATE(block->size() >= 1, ("At ", *block));
109	for (unsigned i = 0; i < block->size() - 1; ++i)	110	for (unsigned i = 0; i < block->size() - 1; ++i)
110	VALIDATE(!ControlValue::accepts(block->at(i)->opcode()), ("At ", *block->at(i)));	111	VALIDATE(!block->at(i)->effects().terminal, ("At ", *block->at(i)));
111	VALIDATE(ControlValue::accepts(block->last()->opcode()), ("At ", *block->last()));	112	VALIDATE(block->last()->effects().terminal, ("At ", *block->last()));
112		113
113	for (BasicBlock* successor : block->successorBlocks()) {	114	for (BasicBlock* successor : block->successorBlocks()) {
114	allPredecessors.add(successor, HashSet<BasicBlock*>()).iterator->value.add(block);	115	allPredecessors.add(successor, HashSet<BasicBlock*>()).iterator->value.add(block);
Lines 129-136 public: Source/JavaScriptCore/b3/B3Validate.cpp_sec3
129	VALIDATE(child->type() != Void, ("At ", value, "->", child));	130	VALIDATE(child->type() != Void, ("At ", value, "->", child));
130	switch (value->opcode()) {	131	switch (value->opcode()) {
131	case Nop:	132	case Nop:
132	case Jump:
133	case Oops:
134	VALIDATE(!value->numChildren(), ("At ", *value));	133	VALIDATE(!value->numChildren(), ("At ", *value));
135	VALIDATE(value->type() == Void, ("At ", *value));	134	VALIDATE(value->type() == Void, ("At ", *value));
136	break;	135	break;
Lines 377-391 public: Source/JavaScriptCore/b3/B3Validate.cpp_sec4
377	VALIDATE(!value->numChildren(), ("At ", *value));	376	VALIDATE(!value->numChildren(), ("At ", *value));
378	VALIDATE(value->type() != Void, ("At ", *value));	377	VALIDATE(value->type() != Void, ("At ", *value));
379	break;	378	break;
		379	case Jump:
		380	VALIDATE(!value->numChildren(), ("At ", *value));
		381	VALIDATE(value->type() == Void, ("At ", *value));
		382	VALIDATE(valueOwner.get(value)->numSuccessors() == 1, ("At ", *value));
		383	break;
		384	case Oops:
		385	VALIDATE(!value->numChildren(), ("At ", *value));
		386	VALIDATE(value->type() == Void, ("At ", *value));
		387	VALIDATE(!valueOwner.get(value)->numSuccessors(), ("At ", *value));
		388	break;
380	case Return:	389	case Return:
381	VALIDATE(value->numChildren() == 1, ("At ", *value));	390	VALIDATE(value->numChildren() == 1, ("At ", *value));
382	VALIDATE(value->type() == Void, ("At ", *value));	391	VALIDATE(value->type() == Void, ("At ", *value));
		392	VALIDATE(!valueOwner.get(value)->numSuccessors(), ("At ", *value));
383	break;	393	break;
384	case Branch:	394	case Branch:
		395	VALIDATE(value->numChildren() == 1, ("At ", *value));
		396	VALIDATE(isInt(value->child(0)->type()), ("At ", *value));
		397	VALIDATE(value->type() == Void, ("At ", *value));
		398	VALIDATE(valueOwner.get(value)->numSuccessors() == 2, ("At ", *value));
		399	break;
385	case Switch:	400	case Switch:
386	VALIDATE(value->numChildren() == 1, ("At ", *value));	401	VALIDATE(value->numChildren() == 1, ("At ", *value));
387	VALIDATE(isInt(value->child(0)->type()), ("At ", *value));	402	VALIDATE(isInt(value->child(0)->type()), ("At ", *value));
388	VALIDATE(value->type() == Void, ("At ", *value));	403	VALIDATE(value->type() == Void, ("At ", *value));
		404	VALIDATE(value->as<SwitchValue>()->hasFallThrough(valueOwner.get(value)), ("At ", *value));
		405	// This validates the same thing as hasFallThrough, but more explicitly. We want to
		406	// make sure that if anyone tries to change the definition of hasFallThrough, they
		407	// will feel some pain here, since this is fundamental.
		408	VALIDATE(valueOwner.get(value)->numSuccessors() == value->as<SwitchValue>()->numCaseValues() + 1, ("At ", *value));
389	break;	409	break;
390	}	410	}
391		411

Lines 29-37 Source/JavaScriptCore/b3/B3Value.cpp_sec1
- Source/JavaScriptCore/b3/B3Value.cpp -1 / +63 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3ArgumentRegValue.h"	31	#include "B3ArgumentRegValue.h"
		32	#include "B3BasicBlockInlines.h"
32	#include "B3BottomProvider.h"	33	#include "B3BottomProvider.h"
33	#include "B3CCallValue.h"	34	#include "B3CCallValue.h"
34	#include "B3ControlValue.h"
35	#include "B3MemoryValue.h"	35	#include "B3MemoryValue.h"
36	#include "B3OriginDump.h"	36	#include "B3OriginDump.h"
37	#include "B3ProcedureInlines.h"	37	#include "B3ProcedureInlines.h"
Lines 42-47 Source/JavaScriptCore/b3/B3Value.cpp_sec2
42	#include "B3ValueKeyInlines.h"	42	#include "B3ValueKeyInlines.h"
43	#include "B3VariableValue.h"	43	#include "B3VariableValue.h"
44	#include <wtf/CommaPrinter.h>	44	#include <wtf/CommaPrinter.h>
		45	#include <wtf/ListDump.h>
45	#include <wtf/StringPrintStream.h>	46	#include <wtf/StringPrintStream.h>
46		47
47	namespace JSC { namespace B3 {	48	namespace JSC { namespace B3 {
Lines 125-130 void Value::replaceWithPhi() Source/JavaScriptCore/b3/B3Value.cpp_sec3
125	this->m_index = index;	126	this->m_index = index;
126	}	127	}
127		128
		129	void Value::replaceWithJump(BasicBlock* owner, const FrequentedBlock& target)
		130	{
		131	RELEASE_ASSERT(owner->last() == this);
		132
		133	unsigned index = m_index;
		134	Origin origin = m_origin;
		135
		136	this->~Value();
		137
		138	new (this) Value(Jump, Void, origin);
		139
		140	this->owner = owner;
		141	this->m_index = index;
		142
		143	owner->setSuccessors(target);
		144	}
		145
		146	void Value::replaceWithOops(BasicBlock* owner)
		147	{
		148	RELEASE_ASSERT(owner->last() == this);
		149
		150	unsigned index = m_index;
		151	Origin origin = m_origin;
		152
		153	this->~Value();
		154
		155	new (this) Value(Oops, Void, origin);
		156
		157	this->owner = owner;
		158	this->m_index = index;
		159
		160	owner->clearSuccessors();
		161	}
		162
		163	void Value::replaceWithJump(const FrequentedBlock& target)
		164	{
		165	replaceWithJump(owner, target);
		166	}
		167
		168	void Value::replaceWithOops()
		169	{
		170	replaceWithOops(owner);
		171	}
		172
128	void Value::dump(PrintStream& out) const	173	void Value::dump(PrintStream& out) const
129	{	174	{
130	bool isConstant = false;	175	bool isConstant = false;
Lines 189-194 void Value::deepDump(const Procedure* pr Source/JavaScriptCore/b3/B3Value.cpp_sec4
189	out.print(")");	234	out.print(")");
190	}	235	}
191		236
		237	void Value::dumpSuccessors(const BasicBlock* block, PrintStream& out) const
		238	{
		239	// Note that this must not crash if we have the wrong number of successors, since someone
		240	// debugging a number-of-successors bug will probably want to dump IR!
		241
		242	if (opcode() == Branch && block->numSuccessors() == 2) {
		243	out.print("Then:", block->taken(), ", Else:", block->notTaken());
		244	return;
		245	}
		246
		247	out.print(listDump(block->successors()));
		248	}
		249
192	Value* Value::negConstant(Procedure&) const	250	Value* Value::negConstant(Procedure&) const
193	{	251	{
194	return nullptr;	252	return nullptr;
Lines 713-718 Type Value::typeFor(Opcode opcode, Value Source/JavaScriptCore/b3/B3Value.cpp_sec5
713	}	771	}
714	return Void;	772	return Void;
715	case Nop:	773	case Nop:
		774	case Jump:
		775	case Branch:
		776	case Return:
		777	case Oops:
716	return Void;	778	return Void;
717	case Select:	779	case Select:
718	ASSERT(secondChild);	780	ASSERT(secondChild);

Lines 50-57 Source/JavaScriptCore/b3/air/AirGenerate.cpp_sec1
- Source/JavaScriptCore/b3/air/AirGenerate.cpp -20 / +36 lines
50	#include "B3IndexMap.h"	50	#include "B3IndexMap.h"
51	#include "B3Procedure.h"	51	#include "B3Procedure.h"
52	#include "B3TimingScope.h"	52	#include "B3TimingScope.h"
		53	#include "B3ValueInlines.h"
53	#include "CCallHelpers.h"	54	#include "CCallHelpers.h"
54	#include "DisallowMacroScratchRegisterUsage.h"	55	#include "DisallowMacroScratchRegisterUsage.h"
		56	#include "LinkBuffer.h"
55		57
56	namespace JSC { namespace B3 { namespace Air {	58	namespace JSC { namespace B3 { namespace Air {
57		59
Lines 173-184 void generate(Code& code, CCallHelpers& Source/JavaScriptCore/b3/air/AirGenerate.cpp_sec2
173		175
174	GenerationContext context;	176	GenerationContext context;
175	context.code = &code;	177	context.code = &code;
176	IndexMap<BasicBlock, CCallHelpers::Label> blockLabels(code.size());	178	context.blockLabels.resize(code.size());
		179	for (BasicBlock* block : code) {
		180	if (block)
		181	context.blockLabels[block] = Box<CCallHelpers::Label>::create();
		182	}
177	IndexMap<BasicBlock, CCallHelpers::JumpList> blockJumps(code.size());	183	IndexMap<BasicBlock, CCallHelpers::JumpList> blockJumps(code.size());
178		184
179	auto link = [&] (CCallHelpers::Jump jump, BasicBlock* target) {	185	auto link = [&] (CCallHelpers::Jump jump, BasicBlock* target) {
180	if (blockLabels[target].isSet()) {	186	if (context.blockLabels[target]->isSet()) {
181	jump.linkTo(blockLabels[target], &jit);	187	jump.linkTo(*context.blockLabels[target], &jit);
182	return;	188	return;
183	}	189	}
184		190
Lines 195-210 void generate(Code& code, CCallHelpers& Source/JavaScriptCore/b3/air/AirGenerate.cpp_sec3
195	};	201	};
196		202
197	for (BasicBlock* block : code) {	203	for (BasicBlock* block : code) {
		204	context.currentBlock = block;
		205	context.indexInBlock = UINT_MAX;
198	blockJumps[block].link(&jit);	206	blockJumps[block].link(&jit);
199	blockLabels[block] = jit.label();	207	CCallHelpers::Label label = jit.label();
		208	*context.blockLabels[block] = label;
200	ASSERT(block->size() >= 1);	209	ASSERT(block->size() >= 1);
201	for (unsigned i = 0; i < block->size() - 1; ++i) {	210	for (unsigned i = 0; i < block->size() - 1; ++i) {
		211	context.indexInBlock = i;
202	Inst& inst = block->at(i);	212	Inst& inst = block->at(i);
203	addItem(inst);	213	addItem(inst);
204	CCallHelpers::Jump jump = inst.generate(jit, context);	214	CCallHelpers::Jump jump = inst.generate(jit, context);
205	ASSERT_UNUSED(jump, !jump.isSet());	215	ASSERT_UNUSED(jump, !jump.isSet());
206	}	216	}
207		217
		218	context.indexInBlock = block->size() - 1;
		219
208	if (block->last().opcode == Jump	220	if (block->last().opcode == Jump
209	&& block->successorBlock(0) == code.findNextBlock(block))	221	&& block->successorBlock(0) == code.findNextBlock(block))
210	continue;	222	continue;
Lines 228-253 void generate(Code& code, CCallHelpers& Source/JavaScriptCore/b3/air/AirGenerate.cpp_sec4
228	addItem(block->last());	240	addItem(block->last());
229	continue;	241	continue;
230	}	242	}
231		243
232	CCallHelpers::Jump jump = block->last().generate(jit, context);	244	CCallHelpers::Jump jump = block->last().generate(jit, context);
233	switch (block->numSuccessors()) {	245	// The jump won't be set for patchpoints. It won't be set for Oops because then it won't have
234	case 0:	246	// any successors.
235	ASSERT(!jump.isSet());	247	if (jump.isSet()) {
236	break;	248	switch (block->numSuccessors()) {
237	case 1:	249	case 1:
238	link(jump, block->successorBlock(0));	250	link(jump, block->successorBlock(0));
239	break;	251	break;
240	case 2:	252	case 2:
241	link(jump, block->successorBlock(0));	253	link(jump, block->successorBlock(0));
242	if (block->successorBlock(1) != code.findNextBlock(block))	254	if (block->successorBlock(1) != code.findNextBlock(block))
243	link(jit.jump(), block->successorBlock(1));	255	link(jit.jump(), block->successorBlock(1));
244	break;	256	break;
245	default:	257	default:
246	RELEASE_ASSERT_NOT_REACHED();	258	RELEASE_ASSERT_NOT_REACHED();
247	break;	259	break;
		260	}
248	}	261	}
249	addItem(block->last());	262	addItem(block->last());
250	}	263	}
		264
		265	context.currentBlock = nullptr;
		266	context.indexInBlock = UINT_MAX;
251		267
252	pcToOriginMap.appendItem(jit.label(), Origin());	268	pcToOriginMap.appendItem(jit.label(), Origin());
253	// FIXME: Make late paths have Origins: https://bugs.webkit.org/show_bug.cgi?id=153689	269	// FIXME: Make late paths have Origins: https://bugs.webkit.org/show_bug.cgi?id=153689

Lines 95-127 bool simplifyCFG(Code& code) Source/JavaScriptCore/b3/air/AirSimplifyCFG.cpp_sec1
- Source/JavaScriptCore/b3/air/AirSimplifyCFG.cpp -22 / +21 lines
95	}	95	}
96	}	96	}
97		97
98	// Now check if the block's terminal can be replaced with a jump.	98	// Now check if the block's terminal can be replaced with a jump. The terminal must not
99	if (block->numSuccessors() > 1) {	99	// have weird effects.
100	// The terminal must not have weird effects.	100	if (block->numSuccessors() > 1
101	if (!block->last().hasArgEffects()	101	&& !block->last().hasNonControlEffects()) {
102	&& !block->last().hasNonArgNonControlEffects()) {	102	// All of the successors must be the same.
103	// All of the successors must be the same.	103	bool allSame = true;
104	bool allSame = true;	104	BasicBlock* firstSuccessor = block->successorBlock(0);
105	BasicBlock* firstSuccessor = block->successorBlock(0);	105	for (unsigned i = 1; i < block->numSuccessors(); ++i) {
106	for (unsigned i = 1; i < block->numSuccessors(); ++i) {	106	if (block->successorBlock(i) != firstSuccessor) {
107	if (block->successorBlock(i) != firstSuccessor) {	107	allSame = false;
108	allSame = false;	108	break;
109	break;
110	}
111	}
112	if (allSame) {
113	if (verbose)
114	dataLog("Changing ", pointerDump(block), "'s terminal to a Jump.\n");
115	block->last() = Inst(Jump, block->last().origin);
116	block->successors().resize(1);
117	block->successors()[0].frequency() = FrequencyClass::Normal;
118	changed = true;
119	}	109	}
120	}	110	}
		111	if (allSame) {
		112	if (verbose)
		113	dataLog("Changing ", pointerDump(block), "'s terminal to a Jump.\n");
		114	block->last() = Inst(Jump, block->last().origin);
		115	block->successors().resize(1);
		116	block->successors()[0].frequency() = FrequencyClass::Normal;
		117	changed = true;
		118	}
121	}	119	}
122		120
123	// Finally handle jumps to a block with one predecessor.	121	// Finally handle jumps to a block with one predecessor.
124	if (block->numSuccessors() == 1) {	122	if (block->numSuccessors() == 1
		123	&& !block->last().hasNonControlEffects()) {
125	BasicBlock* successor = block->successorBlock(0);	124	BasicBlock* successor = block->successorBlock(0);
126	if (successor != block && successor->numPredecessors() == 1) {	125	if (successor != block && successor->numPredecessors() == 1) {
127	RELEASE_ASSERT(successor->predecessor(0) == block);	126	RELEASE_ASSERT(successor->predecessor(0) == block);

Lines 1-5 Source/JavaScriptCore/b3/air/AirValidate.cpp_sec1
- Source/JavaScriptCore/b3/air/AirValidate.cpp -3 / +3 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 79-87 public: Source/JavaScriptCore/b3/air/AirValidate.cpp_sec2
79	}	79	}
80	VALIDATE(inst.isValidForm(), ("At ", inst, " in ", *block));	80	VALIDATE(inst.isValidForm(), ("At ", inst, " in ", *block));
81	if (instIndex == block->size() - 1)	81	if (instIndex == block->size() - 1)
82	VALIDATE(isTerminal(inst.opcode), ("At ", inst, " in ", *block));	82	VALIDATE(inst.isTerminal(), ("At ", inst, " in ", *block));
83	else	83	else
84	VALIDATE(!isTerminal(inst.opcode), ("At ", inst, " in ", *block));	84	VALIDATE(!inst.isTerminal(), ("At ", inst, " in ", *block));
85		85
86	// forEachArg must return Arg&'s that point into the args array.	86	// forEachArg must return Arg&'s that point into the args array.
87	inst.forEachArg(	87	inst.forEachArg(

Lines 714-720 writeH("OpcodeUtils") { Source/JavaScriptCore/b3/air/opcode_generator.rb_sec1
- Source/JavaScriptCore/b3/air/opcode_generator.rb -1 / +27 lines
714	outp.puts "return false; "	714	outp.puts "return false; "
715	outp.puts "}"	715	outp.puts "}"
716		716
717	outp.puts "inline bool isTerminal(Opcode opcode)"	717	outp.puts "inline bool isDefinitelyTerminal(Opcode opcode)"
718	outp.puts "{"	718	outp.puts "{"
719	outp.puts "switch (opcode) {"	719	outp.puts "switch (opcode) {"
720	didFindTerminals = false	720	didFindTerminals = false
Lines 976-981 writeH("OpcodeGenerated") { Source/JavaScriptCore/b3/air/opcode_generator.rb_sec2
976	outp.puts "return false;"	976	outp.puts "return false;"
977	outp.puts "}"	977	outp.puts "}"
978		978
		979	outp.puts "bool Inst::isTerminal()"
		980	outp.puts "{"
		981	outp.puts "switch (opcode) {"
		982	foundTrue = false
		983	$opcodes.values.each {
		984	\| opcode \|
		985	if opcode.attributes[:terminal]
		986	outp.puts "case #{opcode.name}:"
		987	foundTrue = true
		988	end
		989	}
		990	if foundTrue
		991	outp.puts "return true;"
		992	end
		993	$opcodes.values.each {
		994	\| opcode \|
		995	if opcode.custom
		996	outp.puts "case #{opcode.name}:"
		997	outp.puts "return #{opcode.name}Custom::isTerminal(*this);"
		998	end
		999	}
		1000	outp.puts "default:"
		1001	outp.puts "return false;"
		1002	outp.puts "}"
		1003	outp.puts "}"
		1004
979	outp.puts "bool Inst::hasNonArgNonControlEffects()"	1005	outp.puts "bool Inst::hasNonArgNonControlEffects()"
980	outp.puts "{"	1006	outp.puts "{"
981	outp.puts "switch (opcode) {"	1007	outp.puts "switch (opcode) {"

Lines 30-48 Source/JavaScriptCore/ftl/FTLOutput.h_sec1
- Source/JavaScriptCore/ftl/FTLOutput.h -20 / +23 lines
30		30
31	#if ENABLE(FTL_JIT)	31	#if ENABLE(FTL_JIT)
32		32
33	#include "B3ArgumentRegValue.h"
34	#include "B3BasicBlockInlines.h"	33	#include "B3BasicBlockInlines.h"
35	#include "B3CCallValue.h"	34	#include "B3CCallValue.h"
36	#include "B3Compilation.h"	35	#include "B3Compilation.h"
37	#include "B3Const32Value.h"	36	#include "B3FrequentedBlock.h"
38	#include "B3ConstPtrValue.h"
39	#include "B3ControlValue.h"
40	#include "B3MemoryValue.h"
41	#include "B3Procedure.h"	37	#include "B3Procedure.h"
42	#include "B3SlotBaseValue.h"
43	#include "B3SwitchValue.h"	38	#include "B3SwitchValue.h"
44	#include "B3UpsilonValue.h"
45	#include "B3ValueInlines.h"
46	#include "FTLAbbreviatedTypes.h"	39	#include "FTLAbbreviatedTypes.h"
47	#include "FTLAbstractHeapRepository.h"	40	#include "FTLAbstractHeapRepository.h"
48	#include "FTLCommonValues.h"	41	#include "FTLCommonValues.h"
Lines 64-70 Source/JavaScriptCore/ftl/FTLOutput.h_sec2
64		57
65	namespace JSC {	58	namespace JSC {
66		59
67	namespace DFG { struct Node; }	60	namespace DFG {
		61	struct Node;
		62	} // namespace DFG
		63
		64	namespace B3 {
		65	class SlotBaseValue;
		66	} // namespace B3
68		67
69	namespace FTL {	68	namespace FTL {
70		69
Lines 106-114 public: Source/JavaScriptCore/ftl/FTLOutput.h_sec3
106	LValue constBool(bool value);	105	LValue constBool(bool value);
107	LValue constInt32(int32_t value);	106	LValue constInt32(int32_t value);
108	template<typename T>	107	template<typename T>
109	LValue constIntPtr(T* value) { return m_block->appendNew<B3::ConstPtrValue>(m_proc, origin(), value); }	108	LValue constIntPtr(T* value)
		109	{
		110	if (sizeof(void*) == 8)
		111	return constInt64(bitwise_cast<intptr_t>(value));
		112	return constInt32(bitwise_cast<intptr_t>(value));
		113	}
110	template<typename T>	114	template<typename T>
111	LValue constIntPtr(T value) { return m_block->appendNew<B3::ConstPtrValue>(m_proc, origin(), value); }	115	LValue constIntPtr(T value)
		116	{
		117	if (sizeof(void*) == 8)
		118	return constInt64(static_cast<intptr_t>(value));
		119	return constInt32(static_cast<intptr_t>(value));
		120	}
112	LValue constInt64(int64_t value);	121	LValue constInt64(int64_t value);
113	LValue constDouble(double value);	122	LValue constDouble(double value);
114		123
Lines 354-361 public: Source/JavaScriptCore/ftl/FTLOutput.h_sec4
354	LValue callWithoutSideEffects(B3::Type type, Function function, LValue arg1, Args... args)	363	LValue callWithoutSideEffects(B3::Type type, Function function, LValue arg1, Args... args)
355	{	364	{
356	return m_block->appendNew<B3::CCallValue>(m_proc, type, origin(), B3::Effects::none(),	365	return m_block->appendNew<B3::CCallValue>(m_proc, type, origin(), B3::Effects::none(),
357	m_block->appendNew<B3::ConstPtrValue>(m_proc, origin(), bitwise_cast<void*>(function)),	366	constIntPtr(bitwise_cast<void*>(function)), arg1, args...);
358	arg1, args...);
359	}	367	}
360		368
361	template<typename FunctionType>	369	template<typename FunctionType>
Lines 378-385 public: Source/JavaScriptCore/ftl/FTLOutput.h_sec5
378	template<typename VectorType>	386	template<typename VectorType>
379	void switchInstruction(LValue value, const VectorType& cases, LBasicBlock fallThrough, Weight fallThroughWeight)	387	void switchInstruction(LValue value, const VectorType& cases, LBasicBlock fallThrough, Weight fallThroughWeight)
380	{	388	{
381	B3::SwitchValue* switchValue = m_block->appendNew<B3::SwitchValue>(	389	B3::SwitchValue* switchValue = m_block->appendNew<B3::SwitchValue>(m_proc, origin(), value);
382	m_proc, origin(), value, B3::FrequentedBlock(fallThrough));	390	switchValue->setFallThrough(B3::FrequentedBlock(fallThrough));
383	for (const SwitchCase& switchCase : cases) {	391	for (const SwitchCase& switchCase : cases) {
384	int64_t value = switchCase.value()->asInt();	392	int64_t value = switchCase.value()->asInt();
385	B3::FrequentedBlock target(switchCase.target(), switchCase.weight().frequencyClass());	393	B3::FrequentedBlock target(switchCase.target(), switchCase.weight().frequencyClass());
Lines 439-449 inline LValue Output::phi(LType type, co Source/JavaScriptCore/ftl/FTLOutput.h_sec6
439	return phiNode;	447	return phiNode;
440	}	448	}
441		449
442	inline void Output::addIncomingToPhi(LValue phi, ValueFromBlock value)
443	{
444	value.value()->as<B3::UpsilonValue>()->setPhi(phi);
445	}
446
447	template<typename... Params>	450	template<typename... Params>
448	inline void Output::addIncomingToPhi(LValue phi, ValueFromBlock value, Params... theRest)	451	inline void Output::addIncomingToPhi(LValue phi, ValueFromBlock value, Params... theRest)
449	{	452	{

Lines 1-3 Websites/webkit.org/ChangeLog_sec1
- Websites/webkit.org/ChangeLog +11 lines
		1	2016-05-29 Filip Pizlo <fpizlo@apple.com>
		2
		3	Implement table-based switches in B3/Air
		4	https://bugs.webkit.org/show_bug.cgi?id=151141
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Update documentation for the new PolyJump opcode.
		9
		10	* docs/b3/intermediate-representation.html:
		11
1	2016-07-01 Jon Davis <jond@apple.com>	12	2016-07-01 Jon Davis <jond@apple.com>
2		13
3	Added a colorful new image and fixed the Open Graph attribute.	14	Added a colorful new image and fixed the Open Graph attribute.

Lines 1-3 LayoutTests/ChangeLog_sec1
- LayoutTests/ChangeLog +12 lines
		1	2016-05-29 Filip Pizlo <fpizlo@apple.com>
		2
		3	Implement table-based switches in B3/Air
		4	https://bugs.webkit.org/show_bug.cgi?id=151141
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* js/regress/bigswitch-expected.txt: Added.
		9	* js/regress/bigswitch.html: Added.
		10	* js/regress/script-tests/bigswitch.js: Added.
		11	(foo):
		12
1	2016-07-04 Yusuke Suzuki <utatane.tea@gmail.com>	13	2016-07-04 Yusuke Suzuki <utatane.tea@gmail.com>
2		14
3	Unreviewed, skip misc-bugs-847389-jpeg2000.js in jsc stress tests	15	Unreviewed, skip misc-bugs-847389-jpeg2000.js in jsc stress tests

Line 0 LayoutTests/js/regress/bigswitch-expected.txt_sec1
- LayoutTests/js/regress/bigswitch-expected.txt +10 lines
	1	JSRegress/bigswitch
	2
	3	On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
	4
	5
	6	PASS no exception thrown
	7	PASS successfullyParsed is true
	8
	9	TEST COMPLETE
	10

Line 0 LayoutTests/js/regress/bigswitch.html_sec1
- LayoutTests/js/regress/bigswitch.html +12 lines
	1	<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
	2	<html>
	3	<head>
	4	<script src="../../resources/js-test-pre.js"></script>
	5	</head>
	6	<body>
	7	<script src="../../resources/regress-pre.js"></script>
	8	<script src="script-tests/bigswitch.js"></script>
	9	<script src="../../resources/regress-post.js"></script>
	10	<script src="../../resources/js-test-post.js"></script>
	11	</body>
	12	</html>