path: root/js/src/jsapi-tests/testAssemblerBuffer.cpp

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include <stdlib.h>

#include "jsatom.h"

#include "jit/shared/IonAssemblerBufferWithConstantPools.h"

#include "jsapi-tests/tests.h"

// Tests for classes in:
//
//   jit/shared/IonAssemblerBuffer.h
//   jit/shared/IonAssemblerBufferWithConstantPools.h
//
// Classes in js::jit tested:
//
//   BufferOffset
//   BufferSlice (implicitly)
//   AssemblerBuffer
//
//   BranchDeadlineSet
//   Pool (implicitly)
//   AssemblerBufferWithConstantPools
//

BEGIN_TEST(testAssemblerBuffer_BufferOffset)
{
    using js::jit::BufferOffset;

    BufferOffset off1;
    BufferOffset off2(10);

    CHECK(!off1.assigned());
    CHECK(off2.assigned());
    CHECK_EQUAL(off2.getOffset(), 10);
    off1 = off2;
    CHECK(off1.assigned());
    CHECK_EQUAL(off1.getOffset(), 10);

    return true;
}
END_TEST(testAssemblerBuffer_BufferOffset)

BEGIN_TEST(testAssemblerBuffer_AssemblerBuffer)
{
    using js::jit::BufferOffset;
    typedef js::jit::AssemblerBuffer<5 * sizeof(uint32_t), uint32_t> AsmBuf;

    AsmBuf ab;
    CHECK(ab.isAligned(16));
    CHECK_EQUAL(ab.size(), 0u);
    CHECK_EQUAL(ab.nextOffset().getOffset(), 0);
    CHECK(!ab.oom());
    CHECK(!ab.bail());

    BufferOffset off1 = ab.putInt(1000017);
    CHECK_EQUAL(off1.getOffset(), 0);
    CHECK_EQUAL(ab.size(), 4u);
    CHECK_EQUAL(ab.nextOffset().getOffset(), 4);
    CHECK(!ab.isAligned(16));
    CHECK(ab.isAligned(4));
    CHECK(ab.isAligned(1));
    CHECK_EQUAL(*ab.getInst(off1), 1000017u);

    BufferOffset off2 = ab.putInt(1000018);
    CHECK_EQUAL(off2.getOffset(), 4);

    BufferOffset off3 = ab.putInt(1000019);
    CHECK_EQUAL(off3.getOffset(), 8);

    BufferOffset off4 = ab.putInt(1000020);
    CHECK_EQUAL(off4.getOffset(), 12);
    CHECK_EQUAL(ab.size(), 16u);
    CHECK_EQUAL(ab.nextOffset().getOffset(), 16);

    // Last one in the slice.
    BufferOffset off5 = ab.putInt(1000021);
    CHECK_EQUAL(off5.getOffset(), 16);
    CHECK_EQUAL(ab.size(), 20u);
    CHECK_EQUAL(ab.nextOffset().getOffset(), 20);

    BufferOffset off6 = ab.putInt(1000022);
    CHECK_EQUAL(off6.getOffset(), 20);
    CHECK_EQUAL(ab.size(), 24u);
    CHECK_EQUAL(ab.nextOffset().getOffset(), 24);

    // Reference previous slice. Excercise the finger.
    CHECK_EQUAL(*ab.getInst(off1), 1000017u);
    CHECK_EQUAL(*ab.getInst(off6), 1000022u);
    CHECK_EQUAL(*ab.getInst(off1), 1000017u);
    CHECK_EQUAL(*ab.getInst(off5), 1000021u);

    // Too much data for one slice.
    const uint32_t fixdata[] = { 2000036, 2000037, 2000038, 2000039, 2000040, 2000041 };

    // Split payload across multiple slices.
    CHECK_EQUAL(ab.nextOffset().getOffset(), 24);
    BufferOffset good1 = ab.putBytesLarge(sizeof(fixdata), fixdata);
    CHECK_EQUAL(good1.getOffset(), 24);
    CHECK_EQUAL(ab.nextOffset().getOffset(), 48);
    CHECK_EQUAL(*ab.getInst(good1), 2000036u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(32)), 2000038u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(36)), 2000039u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(40)), 2000040u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(44)), 2000041u);

    return true;
}
END_TEST(testAssemblerBuffer_AssemblerBuffer)

BEGIN_TEST(testAssemblerBuffer_BranchDeadlineSet)
{
    typedef js::jit::BranchDeadlineSet<3> DLSet;
    using js::jit::BufferOffset;

    js::LifoAlloc alloc(1024);
    DLSet dls(alloc);

    CHECK(dls.empty());
    CHECK(alloc.isEmpty()); // Constructor must be infallible.
    CHECK_EQUAL(dls.size(), 0u);
    CHECK_EQUAL(dls.maxRangeSize(), 0u);

    // Removing non-existant deadline is OK.
    dls.removeDeadline(1, BufferOffset(7));

    // Add deadlines in increasing order as intended. This is optimal.
    dls.addDeadline(1, BufferOffset(10));
    CHECK(!dls.empty());
    CHECK_EQUAL(dls.size(), 1u);
    CHECK_EQUAL(dls.maxRangeSize(), 1u);
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 10);
    CHECK_EQUAL(dls.earliestDeadlineRange(), 1u);

    // Removing non-existant deadline is OK.
    dls.removeDeadline(1, BufferOffset(7));
    dls.removeDeadline(1, BufferOffset(17));
    dls.removeDeadline(0, BufferOffset(10));
    CHECK_EQUAL(dls.size(), 1u);
    CHECK_EQUAL(dls.maxRangeSize(), 1u);

    // Two identical deadlines for different ranges.
    dls.addDeadline(2, BufferOffset(10));
    CHECK(!dls.empty());
    CHECK_EQUAL(dls.size(), 2u);
    CHECK_EQUAL(dls.maxRangeSize(), 1u);
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 10);

    // It doesn't matter which range earliestDeadlineRange() reports first,
    // but it must report both.
    if (dls.earliestDeadlineRange() == 1) {
        dls.removeDeadline(1, BufferOffset(10));
        CHECK_EQUAL(dls.earliestDeadline().getOffset(), 10);
        CHECK_EQUAL(dls.earliestDeadlineRange(), 2u);
    } else {
        CHECK_EQUAL(dls.earliestDeadlineRange(), 2u);
        dls.removeDeadline(2, BufferOffset(10));
        CHECK_EQUAL(dls.earliestDeadline().getOffset(), 10);
        CHECK_EQUAL(dls.earliestDeadlineRange(), 1u);
    }

    // Add deadline which is the front of range 0, but not the global earliest.
    dls.addDeadline(0, BufferOffset(20));
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 10);
    CHECK(dls.earliestDeadlineRange() > 0);

    // Non-optimal add to front of single-entry range 0.
    dls.addDeadline(0, BufferOffset(15));
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 10);
    CHECK(dls.earliestDeadlineRange() > 0);

    // Append to 2-entry range 0.
    dls.addDeadline(0, BufferOffset(30));
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 10);
    CHECK(dls.earliestDeadlineRange() > 0);

    // Add penultimate entry.
    dls.addDeadline(0, BufferOffset(25));
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 10);
    CHECK(dls.earliestDeadlineRange() > 0);

    // Prepend, stealing earliest from other range.
    dls.addDeadline(0, BufferOffset(5));
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 5);
    CHECK_EQUAL(dls.earliestDeadlineRange(), 0u);

    // Remove central element.
    dls.removeDeadline(0, BufferOffset(20));
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 5);
    CHECK_EQUAL(dls.earliestDeadlineRange(), 0u);

    // Remove front, giving back the lead.
    dls.removeDeadline(0, BufferOffset(5));
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 10);
    CHECK(dls.earliestDeadlineRange() > 0);

    // Remove front, giving back earliest to range 0.
    dls.removeDeadline(dls.earliestDeadlineRange(), BufferOffset(10));
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 15);
    CHECK_EQUAL(dls.earliestDeadlineRange(), 0u);

    // Remove tail.
    dls.removeDeadline(0, BufferOffset(30));
    CHECK_EQUAL(dls.earliestDeadline().getOffset(), 15);
    CHECK_EQUAL(dls.earliestDeadlineRange(), 0u);

    // Now range 0 = [15, 25].
    CHECK_EQUAL(dls.size(), 2u);
    dls.removeDeadline(0, BufferOffset(25));
    dls.removeDeadline(0, BufferOffset(15));
    CHECK(dls.empty());

    return true;
}
END_TEST(testAssemblerBuffer_BranchDeadlineSet)

// Mock Assembler class for testing the AssemblerBufferWithConstantPools
// callbacks.
namespace {

struct TestAssembler;

typedef js::jit::AssemblerBufferWithConstantPools<
  /* SliceSize */ 5 * sizeof(uint32_t),
  /* InstSize */ 4,
  /* Inst */ uint32_t,
  /* Asm */ TestAssembler,
  /* NumShortBranchRanges */ 3> AsmBufWithPool;

struct TestAssembler
{
    // Mock instruction set:
    //
    //   0x1111xxxx - align filler instructions.
    //   0x2222xxxx - manually inserted 'arith' instructions.
    //   0xaaaaxxxx - noop filler instruction.
    //   0xb0bbxxxx - branch xxxx bytes forward. (Pool guard).
    //   0xb1bbxxxx - branch xxxx bytes forward. (Short-range branch).
    //   0xb2bbxxxx - branch xxxx bytes forward. (Veneer branch).
    //   0xb3bbxxxx - branch xxxx bytes forward. (Patched short-range branch).
    //   0xc0ccxxxx - constant pool load (uninitialized).
    //   0xc1ccxxxx - constant pool load to index xxxx.
    //   0xc2ccxxxx - constant pool load xxxx bytes ahead.
    //   0xffffxxxx - pool header with xxxx bytes.

    static const unsigned BranchRange = 36;

    static void InsertIndexIntoTag(uint8_t* load_, uint32_t index)
    {
        uint32_t* load = reinterpret_cast<uint32_t*>(load_);
        MOZ_ASSERT(*load == 0xc0cc0000, "Expected uninitialized constant pool load");
        MOZ_ASSERT(index < 0x10000);
        *load = 0xc1cc0000 + index;
    }

    static void PatchConstantPoolLoad(void* loadAddr, void* constPoolAddr)
    {
        uint32_t* load = reinterpret_cast<uint32_t*>(loadAddr);
        uint32_t index = *load & 0xffff;
        MOZ_ASSERT(*load == (0xc1cc0000 | index), "Expected constant pool load(index)");
        ptrdiff_t offset =
          reinterpret_cast<uint8_t*>(constPoolAddr) - reinterpret_cast<uint8_t*>(loadAddr);
        offset += index * 4;
        MOZ_ASSERT(offset % 4 == 0, "Unaligned constant pool");
        MOZ_ASSERT(offset > 0 && offset < 0x10000, "Pool out of range");
        *load = 0xc2cc0000 + offset;
    }

    static void WritePoolGuard(js::jit::BufferOffset branch, uint32_t* dest,
                               js::jit::BufferOffset afterPool)
    {
        MOZ_ASSERT(branch.assigned());
        MOZ_ASSERT(afterPool.assigned());
        size_t branchOff = branch.getOffset();
        size_t afterPoolOff = afterPool.getOffset();
        MOZ_ASSERT(afterPoolOff > branchOff);
        uint32_t delta = afterPoolOff - branchOff;
        *dest = 0xb0bb0000 + delta;
    }

    static void WritePoolHeader(void* start, js::jit::Pool* p, bool isNatural)
    {
        MOZ_ASSERT(!isNatural, "Natural pool guards not implemented.");
        uint32_t* hdr = reinterpret_cast<uint32_t*>(start);
        *hdr = 0xffff0000 + p->getPoolSize();
    }

    static void PatchShortRangeBranchToVeneer(AsmBufWithPool* buffer, unsigned rangeIdx,
                                              js::jit::BufferOffset deadline,
                                              js::jit::BufferOffset veneer)
    {
        size_t branchOff = deadline.getOffset() - BranchRange;
        size_t veneerOff = veneer.getOffset();
        uint32_t *branch = buffer->getInst(js::jit::BufferOffset(branchOff));

        MOZ_ASSERT((*branch & 0xffff0000) == 0xb1bb0000,
                   "Expected short-range branch instruction");
        // Copy branch offset to veneer. A real instruction set would require
        // some adjustment of the label linked-list.
        *buffer->getInst(veneer) = 0xb2bb0000 | (*branch & 0xffff);
        MOZ_ASSERT(veneerOff > branchOff, "Veneer should follow branch");
        *branch = 0xb3bb0000 + (veneerOff - branchOff);
    }
};
}

BEGIN_TEST(testAssemblerBuffer_AssemblerBufferWithConstantPools)
{
    using js::jit::BufferOffset;

    AsmBufWithPool ab(/* guardSize= */ 1,
                      /* headerSize= */ 1,
                      /* instBufferAlign(unused)= */ 0,
                      /* poolMaxOffset= */ 17,
                      /* pcBias= */ 0,
                      /* alignFillInst= */ 0x11110000,
                      /* nopFillInst= */ 0xaaaa0000,
                      /* nopFill= */ 0);

    CHECK(ab.isAligned(16));
    CHECK_EQUAL(ab.size(), 0u);
    CHECK_EQUAL(ab.nextOffset().getOffset(), 0);
    CHECK(!ab.oom());
    CHECK(!ab.bail());

    // Each slice holds 5 instructions. Trigger a constant pool inside the slice.
    uint32_t poolLoad[] = { 0xc0cc0000 };
    uint32_t poolData[] = { 0xdddd0000, 0xdddd0001, 0xdddd0002, 0xdddd0003 };
    AsmBufWithPool::PoolEntry pe;
    BufferOffset load = ab.allocEntry(1, 1, (uint8_t*)poolLoad, (uint8_t*)poolData, &pe);
    CHECK_EQUAL(pe.index(), 0u);
    CHECK_EQUAL(load.getOffset(), 0);

    // Pool hasn't been emitted yet. Load has been patched by
    // InsertIndexIntoTag.
    CHECK_EQUAL(*ab.getInst(load), 0xc1cc0000);

    // Expected layout:
    //
    //   0: load [pc+16]
    //   4: 0x22220001
    //   8: guard branch pc+12
    //  12: pool header
    //  16: poolData
    //  20: 0x22220002
    //
    ab.putInt(0x22220001);
    // One could argue that the pool should be flushed here since there is no
    // more room. However, the current implementation doesn't dump pool until
    // asked to add data:
    ab.putInt(0x22220002);

    CHECK_EQUAL(*ab.getInst(BufferOffset(0)), 0xc2cc0010u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(4)), 0x22220001u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(8)), 0xb0bb000cu);
    CHECK_EQUAL(*ab.getInst(BufferOffset(12)), 0xffff0004u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(16)), 0xdddd0000u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(20)), 0x22220002u);

    // allocEntry() overwrites the load instruction! Restore the original.
    poolLoad[0] = 0xc0cc0000;

    // Now try with load and pool data on separate slices.
    load = ab.allocEntry(1, 1, (uint8_t*)poolLoad, (uint8_t*)poolData, &pe);
    CHECK_EQUAL(pe.index(), 1u); // Global pool entry index.
    CHECK_EQUAL(load.getOffset(), 24);
    CHECK_EQUAL(*ab.getInst(load), 0xc1cc0000); // Index into current pool.
    ab.putInt(0x22220001);
    ab.putInt(0x22220002);
    CHECK_EQUAL(*ab.getInst(BufferOffset(24)), 0xc2cc0010u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(28)), 0x22220001u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(32)), 0xb0bb000cu);
    CHECK_EQUAL(*ab.getInst(BufferOffset(36)), 0xffff0004u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(40)), 0xdddd0000u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(44)), 0x22220002u);

    // Two adjacent loads to the same pool.
    poolLoad[0] = 0xc0cc0000;
    load = ab.allocEntry(1, 1, (uint8_t*)poolLoad, (uint8_t*)poolData, &pe);
    CHECK_EQUAL(pe.index(), 2u); // Global pool entry index.
    CHECK_EQUAL(load.getOffset(), 48);
    CHECK_EQUAL(*ab.getInst(load), 0xc1cc0000); // Index into current pool.

    poolLoad[0] = 0xc0cc0000;
    load = ab.allocEntry(1, 1, (uint8_t*)poolLoad, (uint8_t*)(poolData + 1), &pe);
    CHECK_EQUAL(pe.index(), 3u); // Global pool entry index.
    CHECK_EQUAL(load.getOffset(), 52);
    CHECK_EQUAL(*ab.getInst(load), 0xc1cc0001); // Index into current pool.

    ab.putInt(0x22220005);

    CHECK_EQUAL(*ab.getInst(BufferOffset(48)), 0xc2cc0010u); // load pc+16.
    CHECK_EQUAL(*ab.getInst(BufferOffset(52)), 0xc2cc0010u); // load pc+16.
    CHECK_EQUAL(*ab.getInst(BufferOffset(56)), 0xb0bb0010u); // guard branch pc+16.
    CHECK_EQUAL(*ab.getInst(BufferOffset(60)), 0xffff0008u); // header 8 bytes.
    CHECK_EQUAL(*ab.getInst(BufferOffset(64)), 0xdddd0000u); // datum 1.
    CHECK_EQUAL(*ab.getInst(BufferOffset(68)), 0xdddd0001u); // datum 2.
    CHECK_EQUAL(*ab.getInst(BufferOffset(72)), 0x22220005u); // putInt(0x22220005)

    // Two loads as above, but the first load has an 8-byte pool entry, and the
    // second load wouldn't be able to reach its data. This must produce two
    // pools.
    poolLoad[0] = 0xc0cc0000;
    load = ab.allocEntry(1, 2, (uint8_t*)poolLoad, (uint8_t*)(poolData+2), &pe);
    CHECK_EQUAL(pe.index(), 4u); // Global pool entry index.
    CHECK_EQUAL(load.getOffset(), 76);
    CHECK_EQUAL(*ab.getInst(load), 0xc1cc0000); // Index into current pool.

    poolLoad[0] = 0xc0cc0000;
    load = ab.allocEntry(1, 1, (uint8_t*)poolLoad, (uint8_t*)poolData, &pe);
    CHECK_EQUAL(pe.index(), 6u); // Global pool entry index. (Prev one is two indexes).
    CHECK_EQUAL(load.getOffset(), 96);
    CHECK_EQUAL(*ab.getInst(load), 0xc1cc0000); // Index into current pool.

    CHECK_EQUAL(*ab.getInst(BufferOffset(76)), 0xc2cc000cu); // load pc+12.
    CHECK_EQUAL(*ab.getInst(BufferOffset(80)), 0xb0bb0010u); // guard branch pc+16.
    CHECK_EQUAL(*ab.getInst(BufferOffset(84)), 0xffff0008u); // header 8 bytes.
    CHECK_EQUAL(*ab.getInst(BufferOffset(88)), 0xdddd0002u); // datum 1.
    CHECK_EQUAL(*ab.getInst(BufferOffset(92)), 0xdddd0003u); // datum 2.

    // Second pool is not flushed yet, and there is room for one instruction
    // after the load. Test the keep-together feature.
    ab.enterNoPool(2);
    ab.putInt(0x22220006);
    ab.putInt(0x22220007);
    ab.leaveNoPool();

    CHECK_EQUAL(*ab.getInst(BufferOffset( 96)), 0xc2cc000cu); // load pc+16.
    CHECK_EQUAL(*ab.getInst(BufferOffset(100)), 0xb0bb000cu); // guard branch pc+12.
    CHECK_EQUAL(*ab.getInst(BufferOffset(104)), 0xffff0004u); // header 4 bytes.
    CHECK_EQUAL(*ab.getInst(BufferOffset(108)), 0xdddd0000u); // datum 1.
    CHECK_EQUAL(*ab.getInst(BufferOffset(112)), 0x22220006u);
    CHECK_EQUAL(*ab.getInst(BufferOffset(116)), 0x22220007u);

    return true;
}
END_TEST(testAssemblerBuffer_AssemblerBufferWithConstantPools)

BEGIN_TEST(testAssemblerBuffer_AssemblerBufferWithConstantPools_ShortBranch)
{
    using js::jit::BufferOffset;

    AsmBufWithPool ab(/* guardSize= */ 1,
                      /* headerSize= */ 1,
                      /* instBufferAlign(unused)= */ 0,
                      /* poolMaxOffset= */ 17,
                      /* pcBias= */ 0,
                      /* alignFillInst= */ 0x11110000,
                      /* nopFillInst= */ 0xaaaa0000,
                      /* nopFill= */ 0);

    // Insert short-range branch.
    BufferOffset br1 = ab.putInt(0xb1bb00cc);
    ab.registerBranchDeadline(1, BufferOffset(br1.getOffset() + TestAssembler::BranchRange));
    ab.putInt(0x22220001);
    BufferOffset off = ab.putInt(0x22220002);
    ab.registerBranchDeadline(1, BufferOffset(off.getOffset() + TestAssembler::BranchRange));
    ab.putInt(0x22220003);
    ab.putInt(0x22220004);

    // Second short-range branch that will be swiped up by hysteresis.
    BufferOffset br2 = ab.putInt(0xb1bb0d2d);
    ab.registerBranchDeadline(1, BufferOffset(br2.getOffset() + TestAssembler::BranchRange));

    // Branch should not have been patched yet here.
    CHECK_EQUAL(*ab.getInst(br1), 0xb1bb00cc);
    CHECK_EQUAL(*ab.getInst(br2), 0xb1bb0d2d);

    // Cancel one of the pending branches.
    // This is what will happen to most branches as they are bound before
    // expiring by Assembler::bind().
    ab.unregisterBranchDeadline(1, BufferOffset(off.getOffset() + TestAssembler::BranchRange));

    off = ab.putInt(0x22220006);
    // Here we may or may not have patched the branch yet, but it is inevitable now:
    //
    //  0: br1 pc+36
    //  4: 0x22220001
    //  8: 0x22220002 (unpatched)
    // 12: 0x22220003
    // 16: 0x22220004
    // 20: br2 pc+20
    // 24: 0x22220006
    CHECK_EQUAL(off.getOffset(), 24);
    // 28: guard branch pc+16
    // 32: pool header
    // 36: veneer1
    // 40: veneer2
    // 44: 0x22220007

    off = ab.putInt(0x22220007);
    CHECK_EQUAL(off.getOffset(), 44);

    // Now the branch must have been patched.
    CHECK_EQUAL(*ab.getInst(br1), 0xb3bb0000 + 36);         // br1 pc+36 (patched)
    CHECK_EQUAL(*ab.getInst(BufferOffset(8)), 0x22220002u);  // 0x22220002 (unpatched)
    CHECK_EQUAL(*ab.getInst(br2), 0xb3bb0000 + 20);         // br2 pc+20 (patched)
    CHECK_EQUAL(*ab.getInst(BufferOffset(28)), 0xb0bb0010u); // br pc+16 (guard)
    CHECK_EQUAL(*ab.getInst(BufferOffset(32)), 0xffff0000u); // pool header 0 bytes.
    CHECK_EQUAL(*ab.getInst(BufferOffset(36)), 0xb2bb00ccu); // veneer1 w/ original 'cc' offset.
    CHECK_EQUAL(*ab.getInst(BufferOffset(40)), 0xb2bb0d2du); // veneer2 w/ original 'd2d' offset.
    CHECK_EQUAL(*ab.getInst(BufferOffset(44)), 0x22220007u);

    return true;
}
END_TEST(testAssemblerBuffer_AssemblerBufferWithConstantPools_ShortBranch)

// Test that everything is put together correctly in the ARM64 assembler.
#if defined(JS_CODEGEN_ARM64)

#include "jit/MacroAssembler-inl.h"

BEGIN_TEST(testAssemblerBuffer_ARM64)
{
    using namespace js::jit;

    js::LifoAlloc lifo(4096);
    TempAllocator alloc(&lifo);
    JitContext jc(cx, &alloc);
    cx->getJitRuntime(cx);
    MacroAssembler masm;

    // Branches to an unbound label.
    Label lab1;
    masm.branch(Assembler::Equal, &lab1);
    masm.branch(Assembler::LessThan, &lab1);
    masm.bind(&lab1);
    masm.branch(Assembler::Equal, &lab1);

    CHECK_EQUAL(masm.getInstructionAt(BufferOffset(0))->InstructionBits(),
                vixl::B_cond | vixl::Assembler::ImmCondBranch(2) | vixl::eq);
    CHECK_EQUAL(masm.getInstructionAt(BufferOffset(4))->InstructionBits(),
                vixl::B_cond | vixl::Assembler::ImmCondBranch(1) | vixl::lt);
    CHECK_EQUAL(masm.getInstructionAt(BufferOffset(8))->InstructionBits(),
                vixl::B_cond | vixl::Assembler::ImmCondBranch(0) | vixl::eq);

    // Branches can reach the label, but the linked list of uses needs to be
    // rearranged. The final conditional branch cannot reach the first branch.
    Label lab2a;
    Label lab2b;
    masm.bind(&lab2a);
    masm.B(&lab2b);
    // Generate 1,100,000 bytes of NOPs.
    for (unsigned n = 0; n < 1100000; n += 4)
        masm.Nop();
    masm.branch(Assembler::LessThan, &lab2b);
    masm.bind(&lab2b);
    CHECK_EQUAL(masm.getInstructionAt(BufferOffset(lab2a.offset()))->InstructionBits(),
                vixl::B | vixl::Assembler::ImmUncondBranch(1100000 / 4 + 2));
    CHECK_EQUAL(masm.getInstructionAt(BufferOffset(lab2b.offset() - 4))->InstructionBits(),
                vixl::B_cond | vixl::Assembler::ImmCondBranch(1) | vixl::lt);

    // Generate a conditional branch that can't reach its label.
    Label lab3a;
    Label lab3b;
    masm.bind(&lab3a);
    masm.branch(Assembler::LessThan, &lab3b);
    for (unsigned n = 0; n < 1100000; n += 4)
        masm.Nop();
    masm.bind(&lab3b);
    masm.B(&lab3a);
    Instruction* bcond3 = masm.getInstructionAt(BufferOffset(lab3a.offset()));
    CHECK_EQUAL(bcond3->BranchType(), vixl::CondBranchType);
    ptrdiff_t delta = bcond3->ImmPCRawOffset() * 4;
    Instruction* veneer = masm.getInstructionAt(BufferOffset(lab3a.offset() + delta));
    CHECK_EQUAL(veneer->BranchType(), vixl::UncondBranchType);
    delta += veneer->ImmPCRawOffset() * 4;
    CHECK_EQUAL(delta, lab3b.offset() - lab3a.offset());
    Instruction* b3 = masm.getInstructionAt(BufferOffset(lab3b.offset()));
    CHECK_EQUAL(b3->BranchType(), vixl::UncondBranchType);
    CHECK_EQUAL(4 * b3->ImmPCRawOffset(), -delta);

    return true;
}
END_TEST(testAssemblerBuffer_ARM64)
#endif /* JS_CODEGEN_ARM64 */