Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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 */
#ifndef jit_shared_Disassembler_shared_h
#define jit_shared_Disassembler_shared_h
#include "mozilla/Atomics.h"
#include "mozilla/Attributes.h"
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include "jstypes.h" // JS_PUBLIC_API
#if defined(JS_DISASM_ARM) || defined(JS_DISASM_ARM64)
namespace js {
class JS_PUBLIC_API Sprinter;
namespace jit {
class Label;
// A wrapper around spew/disassembly functionality. The disassembler is built
// on a per-instruction disassembler (as in our ARM, ARM64 back-ends) and
// formats labels with meaningful names and literals with meaningful values, if
// the assembler creates documentation (with provided helpers) at appropriate
// points.
class DisassemblerSpew {
struct Node {
const Label* key; // Never dereferenced, only used for its value
uint32_t value; // The printable label value
bool bound; // If the label has been seen by spewBind()
Node* next;
Node* lookup(const Label* key);
Node* add(const Label* key, uint32_t value);
bool remove(const Label* key);
uint32_t probe(const Label* l);
uint32_t define(const Label* l);
uint32_t internalResolve(const Label* l);
void spewVA(const char* fmt, va_list args) MOZ_FORMAT_PRINTF(2, 0);
// Set indentation strings. The spewer retains a reference to s.
void setLabelIndent(const char* s);
void setTargetIndent(const char* s);
// Set the spew printer, which will always be used if it is set, regardless
// of whether the system spew channel is enabled or not. The spewer retains
// a reference to sp.
void setPrinter(Sprinter* sp);
// Return true if disassembly spew is disabled and no additional printer is
// set.
bool isDisabled();
// Format and print text on the spew channel; output is suppressed if spew
// is disabled. The output is not indented, and is terminated by a newline.
void spew(const char* fmt, ...) MOZ_FORMAT_PRINTF(2, 3);
// Documentation for a label reference.
struct LabelDoc {
LabelDoc() : doc(0), bound(false), valid(false) {}
LabelDoc(uint32_t doc, bool bound) : doc(doc), bound(bound), valid(true) {}
const uint32_t doc;
const bool bound;
const bool valid;
LabelDoc() = default;
LabelDoc(uint32_t, bool) {}
// Documentation for a literal load.
struct LiteralDoc {
enum class Type { Patchable, I32, U32, I64, U64, F32, F64 };
const Type type;
union {
int32_t i32;
uint32_t u32;
int64_t i64;
uint64_t u64;
float f32;
double f64;
} value;
LiteralDoc() : type(Type::Patchable) {}
explicit LiteralDoc(int32_t v) : type(Type::I32) { value.i32 = v; }
explicit LiteralDoc(uint32_t v) : type(Type::U32) { value.u32 = v; }
explicit LiteralDoc(int64_t v) : type(Type::I64) { value.i64 = v; }
explicit LiteralDoc(uint64_t v) : type(Type::U64) { value.u64 = v; }
explicit LiteralDoc(float v) : type(Type::F32) { value.f32 = v; }
explicit LiteralDoc(double v) : type(Type::F64) { value.f64 = v; }
LiteralDoc() = default;
explicit LiteralDoc(int32_t) {}
explicit LiteralDoc(uint32_t) {}
explicit LiteralDoc(int64_t) {}
explicit LiteralDoc(uint64_t) {}
explicit LiteralDoc(float) {}
explicit LiteralDoc(double) {}
// Reference a label, resolving it to a printable representation.
// NOTE: The printable representation depends on the state of the label, so
// if we call resolve() when emitting & disassembling a branch instruction
// then it should be called before the label becomes Used, if emitting the
// branch can change the label's state.
// If the disassembler is not defined this returns a structure that is
// marked not valid.
LabelDoc refLabel(const Label* l);
// Spew the label information previously gathered by refLabel(), at a point
// where the label is referenced. The output is indented by targetIndent_
// and terminated by a newline.
void spewRef(const LabelDoc& target);
// Spew the label at the point where the label is bound. The output is
// indented by labelIndent_ and terminated by a newline.
void spewBind(const Label* label);
// Spew a retarget directive at the point where the retarget is recorded.
// The output is indented by labelIndent_ and terminated by a newline.
void spewRetarget(const Label* label, const Label* target);
// Format a literal value into the buffer. The buffer is always
// NUL-terminated even if this chops the formatted value.
void formatLiteral(const LiteralDoc& doc, char* buffer, size_t bufsize);
// Print any unbound labels, one per line, with normal label indent and with
// a comment indicating the label is not defined. Labels can be referenced
// but unbound in some legitimate cases, normally for traps. Printing them
// reduces confusion.
void spewOrphans();
Sprinter* printer_;
const char* labelIndent_;
const char* targetIndent_;
uint32_t spewNext_;
Node* nodes_;
uint32_t tag_;
// This global is used to disambiguate concurrently live assemblers, see
// comments in Disassembler-shared.cpp for why this is desirable.
// The variable is atomic to avoid any kind of complaint from thread
// sanitizers etc. However, trying to look at disassembly without using
// --no-threads is basically insane, so you can ignore the multi-threading
// implications here.
static mozilla::Atomic<uint32_t> counter_;
} // namespace jit
} // namespace js
#endif // jit_shared_Disassembler_shared_h