CacheIRAOT.cpp - mozsearch

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * vim: set ts=8 sts=2 et sw=2 tw=80:

 * 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/. */

#ifdef ENABLE_JS_AOT_ICS

#  include "jit/CacheIRAOT.h"

#  include "jsmath.h"

#  include "jstypes.h"

#  include "gc/AllocKind.h"

#  include "jit/CacheIR.h"

#  include "jit/CacheIRAOTGenerated.h"

#  include "jit/JitZone.h"

#  include "js/ScalarType.h"

#  include "js/Value.h"

#  include "vm/CompletionKind.h"

#  include "vm/Opcodes.h"

#  include "wasm/WasmValType.h"

// Include null pointers for "native" pointers: an AOT-loaded stub

// should not bake in an arbitrary pointer observed from a previous

// execution. In any case, the AOT corpus should not include any ICs

// that bake in pointers (baseline does not generate any).

#  if JS_BITS_PER_WORD == 32

#    define NATIVE_NULLPTR 0, 0, 0, 0

#  elif JS_BITS_PER_WORD == 64

#    define NATIVE_NULLPTR 0, 0, 0, 0, 0, 0, 0, 0

#  else

#    error Please add a case for a non-32/64-bit system here.

#  endif

// These correspond to the CacheIRWriter definitions of the serialized

// CacheIR format.

#  define OP(op) \

    uint8_t(uint16_t(CacheOp::op) & 0xff), uint8_t(uint16_t(CacheOp::op) >> 8),

#  define ID(id) id,

#  define OFFSET(off) off,

#  define BOOL(x) x,

#  define BYTE(x) x,

#  define JSOP(op) uint8_t(JSOp::op),

#  define TYPEOFEQOPERAND(value) value,

#  define STATICSTRING(p) NATIVE_NULLPTR,

#  define INT32(i)                                                             \

    uint32_t(i) & 0xff, (uint32_t(i) >> 8) & 0xff, (uint32_t(i) >> 16) & 0xff, \

        (uint32_t(i) >> 24) & 0xff,

#  define UINT32(i) \

    (i) & 0xff, ((i) >> 8) & 0xff, ((i) >> 16) & 0xff, ((i) >> 24) & 0xff,

#  define CALLFLAGS(f) f,

#  define WHYMAGIC(m) m,

#  define SCALARTYPE(name) uint8_t(Scalar::Type::name),

#  define UNARYMATHFUNC(name) uint8_t(UnaryMathFunction::name),

#  define VALUETYPE(name) uint8_t(name),

#  define NATIVEIMM(p) NATIVE_NULLPTR,

#  define GUARDCLASSKIND(name) uint8_t(GuardClassKind::name),

#  define ARRAYBUFFERVIEWKIND(name) uint8_t(ArrayBufferViewKind::name),

#  define WASMVALTYPE(name) uint8_t(wasm::ValType::Kind::name),

#  define ALLOCKIND(name) uint8_t(gc::AllocKind::name),

#  define COMPLETIONKIND(name) uint8_t(CompletionKind::name),

#  define REALMFUSE(i) i,

// Other macros used to serialize parts of the CacheIRWriter.

#  define STUBFIELD(ty) AOTStubFieldData{StubField::Type::ty, 0},

#  define LASTUSED(n) n,

// First, generate individual IC bodies.

#  define IC_BODY(idx, _kind, _num_input_operands, _num_operand_ids,        \

                  _num_instructions, _typedata, _stubdatasize, _stubfields, \

                  _lastused, ops)                                           \

    static const uint8_t IC##idx[] = {ops};

JS_AOT_IC_DATA(IC_BODY)

// Generate the stubfield lists.

#  define IC_STUBFIELD(idx, _kind, _num_input_operands, _num_operand_ids, \

                       _num_instructions, _typedata, _stubdatasize,       \

                       stubfields, _lastused, _ops)                       \

    static const AOTStubFieldData IC##idx##StubFields[] = {stubfields};

JS_AOT_IC_DATA(IC_STUBFIELD)

// Generate the operand-last-used lists.

#  define IC_LASTUSED(idx, _kind, _num_input_operands, _num_operand_ids, \

                      _num_instructions, _typedata, _stubdatasize,       \

                      _stubfields, lastused, _ops)                       \

    static const uint32_t IC##idx##LastUsed[] = {lastused};

JS_AOT_IC_DATA(IC_LASTUSED)

// Now, generate the toplevel list of AOT structs from which we can

// reconstitute a CacheIRWriter.

#  define IC_TOP(idx, kind, num_input_operands, num_operand_ids,        \

                 num_instructions, typedata, stubdatasize, _stubfields, \

                 _lastused, _ops)                                       \

    CacheIRAOTStub{                                                     \

        CacheKind::kind,                                                \

        num_operand_ids,                                                \

        num_input_operands,                                             \

        num_instructions,                                               \

        TypeData(typedata),                                             \

        stubdatasize,                                                   \

        IC##idx##StubFields,                                            \

        sizeof(IC##idx##StubFields) / sizeof(IC##idx##StubFields[0]),   \

        IC##idx##LastUsed,                                              \

        IC##idx,                                                        \

        sizeof(IC##idx)},

static const CacheIRAOTStub stubs[] = {JS_AOT_IC_DATA(IC_TOP)};

mozilla::Span<const CacheIRAOTStub> js::jit::GetAOTStubs() {

  return mozilla::Span(stubs, sizeof(stubs) / sizeof(stubs[0]));

CacheIRWriter::CacheIRWriter(JSContext* cx, const CacheIRAOTStub& stub)

    : CustomAutoRooter(cx),

#  ifdef DEBUG

      cx_(cx),

#  endif

      tooLarge_(false),

      lastOffset_(0),

      lastIndex_(0) {

  nextOperandId_ = stub.numOperandIds;

  nextInstructionId_ = stub.numInstructions;

  numInputOperands_ = stub.numInputOperands;

  typeData_ = stub.typeData;

  stubDataSize_ = stub.stubDataSize;

  for (size_t i = 0; i < stub.stubfieldCount; i++) {

    buffer_.propagateOOM(stubFields_.append(

        StubField(stub.stubfields[i].data, stub.stubfields[i].type)));

  for (uint32_t i = 0; i < stub.numOperandIds; i++) {

    buffer_.propagateOOM(operandLastUsed_.append(stub.operandLastUsed[i]));

  buffer_.writeBytes(stub.data, stub.dataLength);

#endif /* ENABLE_JS_AOT_ICS */