| /* |
| * Copyright (C) 2016-2017 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. |
| */ |
| "use strict"; |
| |
| /* |
| * Base utility types for the AST. |
| * |
| * Valid methods for Node: |
| * |
| * node.children -> Returns an array of immediate children. It has been modified |
| * from the original Ruby version to dump directly nearly the original source. |
| * |
| * node.descendents -> Returns an array of all strict descendants (children |
| * and children of children, transitively). |
| * |
| */ |
| |
| class Node |
| { |
| constructor(codeOrigin) |
| { |
| this._codeOrigin = codeOrigin; |
| } |
| |
| get codeOriginString() |
| { |
| return this._codeOrigin.toString(); |
| } |
| |
| get codeOrigin() |
| { |
| return this._codeOrigin; |
| } |
| } |
| |
| class NoChildren extends Node |
| { |
| constructor(codeOrigin) |
| { |
| super(codeOrigin); |
| } |
| |
| children() |
| { |
| return []; |
| } |
| } |
| |
| function structOffsetKey(struct, field) |
| { |
| return struct + "::" + field; |
| } |
| |
| // AST nodes. |
| |
| class StructOffset extends NoChildren |
| { |
| constructor(codeOrigin, struct, field) |
| { |
| super(codeOrigin); |
| this._struct = struct; |
| this._field = field; |
| } |
| |
| static forField(codeOrigin, struct, field) |
| { |
| let key = structOffsetKey(struct, field); |
| |
| if (!this.mapping[key]) |
| this.mapping[key] = new StructOffset(codeOrigin, struct, field); |
| |
| return this.mapping[key]; |
| } |
| |
| static resetMappings() |
| { |
| this.mapping = {}; |
| } |
| |
| dump() |
| { |
| return this.struct + "::" + this.field; |
| } |
| |
| compare(other) |
| { |
| if (this.struct != other.struct) |
| return this.struct.localeCompare(other.struct); |
| |
| return this.field.localeCompare(other.field); |
| } |
| |
| get struct() |
| { |
| return this._struct; |
| } |
| |
| get field() |
| { |
| return this._field; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| StructOffset.mapping = {}; |
| |
| class Sizeof extends NoChildren |
| { |
| constructor(codeOrigin, struct) |
| { |
| super(codeOrigin); |
| this._struct = struct; |
| } |
| |
| static forName(codeOrigin, struct) |
| { |
| if (!this.mapping[struct]) |
| this.mapping[struct] = new Sizeof(codeOrigin, struct); |
| |
| return this.mapping[struct]; |
| } |
| |
| static resetMappings() |
| { |
| this.mapping = {}; |
| } |
| |
| dump() |
| { |
| return "sizeof " + this.struct; |
| } |
| |
| compare(other) |
| { |
| return this.struct.localeCompare(other.struct); |
| } |
| |
| get struct() |
| { |
| return this._struct; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| Sizeof.mapping = {}; |
| |
| class Immediate extends NoChildren |
| { |
| constructor(codeOrigin, value) |
| { |
| super(codeOrigin); |
| if (value instanceof Number) |
| value = value.valueOf(); |
| this._value = value; |
| if (typeof(value) != "number") |
| throw "Bad immediate value " + value.inspect() + " at " + this.codeOriginString(); |
| } |
| |
| dump() |
| { |
| return this.value.toString(); |
| } |
| |
| equals(other) |
| { |
| return other instanceof Immediate && other.value == this.value; |
| } |
| |
| get value() |
| { |
| return this._value; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isImmediateOperand() |
| { |
| return true; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class AddImmediates extends Node |
| { |
| constructor(codeOrigin, left, right) |
| { |
| super(codeOrigin); |
| this._left = left; |
| this._right = right; |
| } |
| |
| children() |
| { |
| return [this.left, this.right]; |
| } |
| |
| dump() |
| { |
| return "(" + this.left.dump() + " + " + this.right.dump() + ")"; |
| } |
| |
| value() |
| { |
| return (this.left.value() + this.right.value()).toString(); |
| } |
| |
| get left() |
| { |
| return this._left; |
| } |
| |
| get right() |
| { |
| return this._right; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isImmediateOperand() |
| { |
| return true; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class SubImmediates extends Node |
| { |
| constructor(codeOrigin, left, right) |
| { |
| super(codeOrigin); |
| this._left = left; |
| this._right = right; |
| } |
| |
| children() |
| { |
| return [this.left, this.right]; |
| } |
| |
| dump() |
| { |
| return "(" + this.left.dump() + " - " + this.right.dump() + ")"; |
| } |
| |
| value() |
| { |
| return (this.left.value() - this.right.value()).toString(); |
| } |
| |
| get left() |
| { |
| return this._left; |
| } |
| |
| get right() |
| { |
| return this._right; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isImmediateOperand() |
| { |
| return true; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class MulImmediates extends Node |
| { |
| constructor(codeOrigin, left, right) |
| { |
| super(codeOrigin); |
| this._left = left; |
| this._right = right; |
| } |
| |
| children() |
| { |
| return [this.left, this.right]; |
| } |
| |
| dump() |
| { |
| return "(" + this.left.dump() + " * " + this.right.dump() + ")"; |
| } |
| |
| get left() |
| { |
| return this._left; |
| } |
| |
| get right() |
| { |
| return this._right; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class NegImmediate extends Node |
| { |
| constructor(codeOrigin, child) |
| { |
| super(codeOrigin); |
| this._child = child; |
| } |
| |
| children() |
| { |
| return [this.child]; |
| } |
| |
| dump() |
| { |
| return "(-" + this.child.dump() + ")"; |
| } |
| |
| get child() |
| { |
| return this._child; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class OrImmediates extends Node |
| { |
| constructor(codeOrigin, left, right) |
| { |
| super(codeOrigin); |
| this._left = left; |
| this._right = right; |
| } |
| |
| children() |
| { |
| return [this.left, this.right]; |
| } |
| |
| dump() |
| { |
| return "(" + this.left.dump() + " | " + this.right.dump() + ")"; |
| } |
| |
| get left() |
| { |
| return this._left; |
| } |
| |
| get right() |
| { |
| return this._right; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class AndImmediates extends Node |
| { |
| constructor(codeOrigin, left, right) |
| { |
| super(codeOrigin); |
| this._left = left; |
| this._right = right; |
| } |
| |
| children() |
| { |
| return [this.left, this.right]; |
| } |
| |
| dump() |
| { |
| return "(" + this.left.dump() + " & " + this.right.dump() + ")"; |
| } |
| |
| get left() |
| { |
| return this._left; |
| } |
| |
| get right() |
| { |
| return this._right; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class XorImmediates extends Node |
| { |
| constructor(codeOrigin, left, right) |
| { |
| super(codeOrigin); |
| this._left = left; |
| this._right = right; |
| } |
| |
| children() |
| { |
| return [this.left, this.right]; |
| } |
| |
| dump() |
| { |
| return "(" + this.left.dump() + " ^ " + this.right.dump() + ")"; |
| } |
| |
| get left() |
| { |
| return this._left; |
| } |
| |
| get right() |
| { |
| return this._right; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class BitnotImmediate extends Node |
| { |
| constructor(codeOrigin, child) |
| { |
| super(codeOrigin); |
| this._child = child; |
| } |
| |
| children() |
| { |
| return [this.child]; |
| } |
| |
| dump() |
| { |
| return "(~" + this.child.dump() + ")"; |
| } |
| |
| get child() |
| { |
| return this._child; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return true; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class StringLiteral extends NoChildren |
| { |
| constructor(codeOrigin, value) |
| { |
| super(codeOrigin); |
| if (!value instanceof String || value[0] != "\"" || value.slice(-1) != "\"") |
| throw "Bad string literal " + value.inspect() + " at " + this.codeOriginString(); |
| this._value = value.slice(1, -1); |
| } |
| |
| dump() |
| { |
| return "\"" + this.value + "\""; |
| } |
| |
| equals(other) |
| { |
| return other instanceof StringLiteral && other.value == this.value; |
| } |
| |
| get value() |
| { |
| return this._value; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return false; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class RegisterID extends NoChildren |
| { |
| constructor(codeOrigin, name) |
| { |
| super(codeOrigin); |
| this._name = name; |
| } |
| |
| static forName(codeOrigin, name) |
| { |
| if (!this.mapping[name]) |
| this.mapping[name] = new RegisterID(codeOrigin, name); |
| |
| return this.mapping[name]; |
| } |
| |
| dump() |
| { |
| return this.name; |
| } |
| |
| get name() |
| { |
| return this._name; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return true; |
| } |
| } |
| |
| RegisterID.mapping = {}; |
| |
| class FPRegisterID extends NoChildren |
| { |
| constructor(codeOrigin, name) |
| { |
| super(codeOrigin); |
| this._name = name; |
| } |
| |
| static forName(codeOrigin, name) |
| { |
| if (!this.mapping[name]) |
| this.mapping[name] = new FPRegisterID(codeOrigin, name); |
| |
| return this.mapping[name]; |
| } |
| |
| dump() |
| { |
| return this.name; |
| } |
| |
| get name() |
| { |
| return this._name; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return false; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return true; |
| } |
| } |
| |
| FPRegisterID.mapping = {}; |
| |
| class SpecialRegister extends NoChildren |
| { |
| constructor(name) |
| { |
| this._name = name; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return false; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return true; |
| } |
| } |
| |
| class Variable extends NoChildren |
| { |
| constructor(codeOrigin, name) |
| { |
| super(codeOrigin); |
| this._name = name; |
| } |
| |
| static forName(codeOrigin, name) |
| { |
| if (!this.mapping[name]) |
| this.mapping[name] = new Variable(codeOrigin, name); |
| |
| return this.mapping[name]; |
| } |
| |
| dump() |
| { |
| return this.name; |
| } |
| |
| get name() |
| { |
| return this._name; |
| } |
| |
| inspect() |
| { |
| return "<variable " + this.name + " at " + this.codeOriginString(); |
| } |
| } |
| |
| Variable.mapping = {}; |
| |
| class Address extends Node |
| { |
| constructor(codeOrigin, base, offset) |
| { |
| super(codeOrigin); |
| this._base = base; |
| this._offset = offset; |
| if (!base instanceof Variable && !base.register) |
| throw "Bad base for address " + base.inspect() + " at " + this.codeOriginString(); |
| if (!offset instanceof Variable && !offset.immediate()) |
| throw "Bad offset for address " + offset.inspect() + " at " + this.codeOriginString(); |
| } |
| |
| withOffset(extraOffset) |
| { |
| return new Address(this.codeOrigin, this.base, new Immediate(this.codeOrigin, this.offset.value + extraOffset)); |
| } |
| |
| children() |
| { |
| return [this.base, this.offset]; |
| } |
| |
| dump() |
| { |
| return this.offset.dump() + "[" + this.base.dump() + "]"; |
| } |
| |
| get base() |
| { |
| return this._base; |
| } |
| |
| get offset() |
| { |
| return this._offset; |
| } |
| |
| get isAddress() |
| { |
| return true; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return false; |
| } |
| |
| get isImmediateOperand() |
| { |
| return true; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class BaseIndex extends Node |
| { |
| constructor(codeOrigin, base, index, scale, offset) |
| { |
| super(codeOrigin); |
| this._base = base; |
| this._index = index; |
| this._scale = scale; |
| if (![1, 2, 4, 8].includes(this._scale)) |
| throw "Bad scale " + this._scale + " at " + this.codeOriginString(); |
| this._offset = offset; |
| } |
| |
| scaleShift() |
| { |
| switch(this.scale) |
| { |
| case 1: |
| return 0; |
| case 2: |
| return 1; |
| case 4: |
| return 2; |
| case 8: |
| return 3; |
| default: |
| throw "Bad scale " + this.scale + " at " + this.codeOriginString(); |
| } |
| } |
| |
| withOffset(extraOffset) |
| { |
| return new BaseIndex(codeOrigin, this.base, this.index, this.scale, new Immediate(codeOrigin, this.offset.value + extraOffset)); |
| } |
| |
| children() |
| { |
| return [this.base, this.index, this.offset]; |
| } |
| |
| dump() |
| { |
| return this.offset.dump() + "[" + this.base.dump() + ", " + this.index.dump() + ", " + this.scale + "]"; |
| } |
| |
| get base() |
| { |
| return this._base; |
| } |
| |
| get index() |
| { |
| return this._index; |
| } |
| |
| get scale() |
| { |
| return this._scale; |
| } |
| |
| get offset() |
| { |
| return this._offset; |
| } |
| |
| get isAddress() |
| { |
| return true; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return false; |
| } |
| |
| get isImmediateOperand() |
| { |
| return false; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class AbsoluteAddress extends NoChildren |
| { |
| constructor(codeOrigin, address) |
| { |
| super(codeOrigin); |
| this._address = address; |
| } |
| |
| withOffset(extraOffset) |
| { |
| return new AbsoluteAddress(codeOrigin, new Immediate(codeOrigin, this.address.value + extraOffset)); |
| } |
| |
| dump() |
| { |
| return this.address.dump() + "[]"; |
| } |
| |
| get address() |
| { |
| return this._address; |
| } |
| |
| get isAddress() |
| { |
| return true; |
| } |
| |
| get isLabel() |
| { |
| return false; |
| } |
| |
| get isImmediate() |
| { |
| return false; |
| } |
| |
| get isImmediateOperand() |
| { |
| return true; |
| } |
| |
| get isRegister() |
| { |
| return false; |
| } |
| } |
| |
| class Instruction extends Node |
| { |
| constructor(codeOrigin, opcode, operands, annotation=nil) |
| { |
| super(codeOrigin); |
| this._opcode = opcode; |
| this._operands = operands; |
| this._annotation = annotation; |
| } |
| |
| children() |
| { |
| return []; |
| } |
| |
| dump() |
| { |
| return " " + this.opcode + " " + (this.operands.map(function(v) { return v.dump(); }).join(", ")); |
| } |
| |
| get opcode() |
| { |
| return this._opcode; |
| } |
| |
| get operands() |
| { |
| return this._operands; |
| } |
| |
| get annotation() |
| { |
| return this._annotation; |
| } |
| } |
| |
| class Error extends NoChildren |
| { |
| constructor(codeOrigin) |
| { |
| super(codeOrigin); |
| } |
| |
| dump() |
| { |
| return " error"; |
| } |
| } |
| |
| class ConstExpr extends NoChildren |
| { |
| constructor(codeOrigin, value) |
| { |
| super(codeOrigin); |
| this._value = value; |
| } |
| |
| static forName(codeOrigin, text) |
| { |
| if (!this.mapping[text]) |
| this.mapping[text] = new ConstExpr(codeOrigin, text); |
| |
| return this.mapping[text]; |
| } |
| |
| static resetMappings() |
| { |
| this.mapping = {}; |
| } |
| |
| dump() |
| { |
| return "constexpr (" + this.value + ")"; |
| } |
| |
| compare(other) |
| { |
| return this.value(other.value); |
| } |
| |
| isImmediate() |
| { |
| return true; |
| } |
| |
| get variable() |
| { |
| return this._variable; |
| } |
| |
| get value() |
| { |
| return this._value; |
| } |
| } |
| |
| ConstExpr.mapping = {}; |
| |
| |
| class ConstDecl extends Node |
| { |
| constructor(codeOrigin, variable, value) |
| { |
| super(codeOrigin); |
| this._variable = variable; |
| this._value = value; |
| } |
| |
| children() |
| { |
| return [this.variable, this.value]; |
| } |
| |
| dump() |
| { |
| return "const " + this.variable.dump() + " = " + this.value.dump(); |
| } |
| |
| get variable() |
| { |
| return this._variable; |
| } |
| |
| get value() |
| { |
| return this._value; |
| } |
| } |
| |
| let _labelMapping = {}; |
| let _referencedExternLabels = []; |
| |
| class Label extends NoChildren |
| { |
| constructor(codeOrigin, name) |
| { |
| super(codeOrigin); |
| this._name = name; |
| this._extern = true; |
| this._global = false; |
| } |
| |
| static forName(codeOrigin, name, definedInFile) |
| { |
| if (_labelMapping[name]) { |
| if (!_labelMapping[name] instanceof Label) |
| throw "Label name collision: " + name; |
| } else |
| _labelMapping[name] = new Label(codeOrigin, name); |
| |
| if (definedInFile) |
| _labelMapping[name].clearExtern(); |
| |
| return _labelMapping[name]; |
| } |
| |
| static setAsGlobal(codeOrigin, name) |
| { |
| if (_labelMapping[name]) { |
| let label = _labelMapping[name]; |
| if (label.isGlobal()) |
| throw "Label: " + name + " declared global multiple times"; |
| label.setGlobal(); |
| } else { |
| let newLabel = new Label(codeOrigin, name); |
| newLabel.setGlobal(); |
| _labelMapping[name] = newLabel; |
| } |
| } |
| |
| static resetMappings() |
| { |
| _labelMapping = {}; |
| _referencedExternLabels = []; |
| } |
| |
| |
| static resetReferenced() |
| { |
| _referencedExternLabels = []; |
| } |
| |
| clearExtern() |
| { |
| this._extern = false; |
| } |
| |
| isExtern() |
| { |
| return this._extern; |
| } |
| |
| setGlobal() |
| { |
| this._global = true; |
| } |
| |
| isGlobal() |
| { |
| return this._global; |
| } |
| |
| dump() |
| { |
| return this.name + ":"; |
| } |
| |
| get name() |
| { |
| return this._name; |
| } |
| } |
| |
| class LocalLabel extends NoChildren |
| { |
| constructor(codeOrigin, name) |
| { |
| super(codeOrigin); |
| this._name = name; |
| } |
| |
| static forName(codeOrigin, name) |
| { |
| if (_labelMapping[name]) { |
| if (!_labelMapping[name] instanceof LocalLabel) |
| throw "Label name collision: " + name; |
| } else |
| _labelMapping[name] = new LocalLabel(codeOrigin, name); |
| |
| return _labelMapping[name]; |
| } |
| |
| static unique(comment) |
| { |
| let newName = "_" + comment; |
| if (_labelMapping[newName]) { |
| while (_labelMapping[newName = "_#" + this.uniqueNameCounter + "_" + comment]) |
| this.uniqueNameCounter++; |
| } |
| |
| return forName(undefined, newName); |
| } |
| |
| static resetMappings() |
| { |
| this.uniquNameCounter = 0; |
| } |
| |
| cleanName() |
| { |
| if (/^\./.test(this._name)) |
| return "_" + this._name.slice(1); |
| |
| return this._name; |
| } |
| |
| isGlobal() |
| { |
| return false; |
| } |
| |
| dump() |
| { |
| return this.name + ":"; |
| } |
| |
| get name() |
| { |
| return this._name; |
| } |
| } |
| |
| LocalLabel.uniqueNameCounter = 0; |
| |
| |
| class LabelReference extends Node |
| { |
| constructor(codeOrigin, label) |
| { |
| super(codeOrigin); |
| this._label = label; |
| } |
| |
| children() |
| { |
| return [this.label]; |
| } |
| |
| name() |
| { |
| return this.label.name; |
| } |
| |
| isExtern() |
| { |
| return _labelMapping[name] instanceof Label && _labelMapping[name].isExtern(); |
| } |
| |
| used() |
| { |
| if (!_referencedExternLabels.include(this._label) && this.isExtern()) |
| _referencedExternLabels.push(this._label); |
| } |
| |
| dump() |
| { |
| return this.label.name; |
| } |
| |
| value() |
| { |
| return asmLabel(); |
| } |
| |
| get label() |
| { |
| return this._label; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return true; |
| } |
| |
| get isImmediate() |
| { |
| return false; |
| } |
| |
| get isImmediateOperand() |
| { |
| return true; |
| } |
| } |
| |
| class LocalLabelReference extends NoChildren |
| { |
| constructor(codeOrigin, label) |
| { |
| super(codeOrigin); |
| this._label = label; |
| } |
| |
| children() |
| { |
| return [this._label]; |
| } |
| |
| name() |
| { |
| return this.label.name; |
| } |
| |
| dump() |
| { |
| return this.label.name; |
| } |
| |
| value() |
| { |
| return asmLabel(); |
| } |
| |
| get label() |
| { |
| return this._label; |
| } |
| |
| get isAddress() |
| { |
| return false; |
| } |
| |
| get isLabel() |
| { |
| return true; |
| } |
| |
| get isImmediate() |
| { |
| return false; |
| } |
| |
| get isImmediateOperand() |
| { |
| return true; |
| } |
| } |
| |
| class Sequence extends Node |
| { |
| constructor(codeOrigin, list) |
| { |
| super(codeOrigin); |
| this._list = list; |
| } |
| |
| children() |
| { |
| return this.list; |
| } |
| |
| dump() |
| { |
| return "" + this.list.map(function(v) { return v.dump()}).join("\n"); |
| } |
| |
| get list() |
| { |
| return this._list; |
| } |
| } |
| |
| class True extends NoChildren |
| { |
| constructor() |
| { |
| super(undefined); |
| } |
| |
| static instance() |
| { |
| return True.instance; |
| } |
| |
| value() |
| { |
| return true; |
| } |
| |
| dump() |
| { |
| return "true"; |
| } |
| } |
| |
| True.instance = new True(); |
| |
| class False extends NoChildren |
| { |
| constructor() |
| { |
| super(undefined); |
| } |
| |
| static instance() |
| { |
| return False.instance; |
| } |
| |
| value() |
| { |
| return false; |
| } |
| |
| dump() |
| { |
| return "false"; |
| } |
| } |
| |
| False.instance = new False(); |
| |
| class Setting extends NoChildren |
| { |
| constructor(codeOrigin, name) |
| { |
| super(codeOrigin); |
| this._name = name; |
| } |
| |
| static forName(codeOrigin, name) |
| { |
| if (!this.mapping[name]) |
| this.mapping[name] = new Setting(codeOrigin, name); |
| |
| return this.mapping[name]; |
| } |
| |
| static resetMappings() |
| { |
| this.mapping = {}; |
| } |
| |
| dump() |
| { |
| return this.name; |
| } |
| |
| get name() |
| { |
| return this._name; |
| } |
| } |
| |
| Setting.mapping = {}; |
| |
| class And extends Node |
| { |
| constructor(codeOrigin, left, right) |
| { |
| super(codeOrigin); |
| this._left = left; |
| this._right = right; |
| } |
| |
| children() |
| { |
| return [this.left, this.right]; |
| } |
| |
| dump() |
| { |
| return "(" + this.left.dump() + " and " + this.right.dump() + ")"; |
| } |
| |
| get left() |
| { |
| return this._left; |
| } |
| |
| get right() |
| { |
| return this._right; |
| } |
| } |
| |
| class Or extends Node |
| { |
| constructor(codeOrigin, left, right) |
| { |
| super(codeOrigin); |
| this._left = left; |
| this._right = right; |
| } |
| |
| children() |
| { |
| return [this.left, this.right]; |
| } |
| |
| dump() |
| { |
| return "(" + this.left.dump() + " or " + this.right.dump() + ")"; |
| } |
| |
| get left() |
| { |
| return this._left; |
| } |
| |
| get right() |
| { |
| return this._right; |
| } |
| } |
| |
| class Not extends Node |
| { |
| constructor(codeOrigin, child) |
| { |
| super(codeOrigin); |
| this._child = child; |
| } |
| |
| children() |
| { |
| return [this.child]; |
| } |
| |
| dump() |
| { |
| return "(not" + this.child.dump() + ")"; |
| } |
| |
| get child() |
| { |
| return this._child; |
| } |
| } |
| |
| class Skip extends NoChildren |
| { |
| constructor(codeOrigin) |
| { |
| super(codeOrigin); |
| } |
| |
| dump() |
| { |
| return " skip"; |
| } |
| } |
| |
| class IfThenElse extends Node |
| { |
| constructor(codeOrigin, predicate, thenCase) |
| { |
| super(codeOrigin); |
| this._predicate = predicate; |
| this._thenCase = thenCase; |
| this._elseCase = new Skip(codeOrigin); |
| } |
| |
| children() |
| { |
| return []; |
| } |
| |
| dump() |
| { |
| return "if " + this.predicate.dump() + "\n" + this.thenCase.dump() + "\nelse\n" + this.elseCase.dump() + "\nend"; |
| } |
| |
| get predicate() |
| { |
| return this._predicate; |
| } |
| |
| get thenCase() |
| { |
| return this._thenCase; |
| } |
| |
| get elseCase() |
| { |
| return this._elseCase; |
| } |
| |
| set elseCase(newElseCase) |
| { |
| this._elseCase = newElseCase; |
| } |
| } |
| |
| class Macro extends Node |
| { |
| constructor(codeOrigin, name, variables, body) |
| { |
| super(codeOrigin); |
| this._name = name; |
| this._variables = variables; |
| this._body = body; |
| } |
| |
| children() |
| { |
| return []; |
| } |
| |
| dump() |
| { |
| return "macro " + this.name + "(" + this.variables.map(function(v) { return v.dump()}).join(", ") + ")\n" + this.body.dump() + "\nend"; |
| } |
| |
| get name() |
| { |
| return this._name; |
| } |
| |
| get variables() |
| { |
| return this._variables; |
| } |
| |
| get body() |
| { |
| return this._body; |
| } |
| } |
| |
| class MacroCall extends Node |
| { |
| constructor(codeOrigin, name, operands, annotation) |
| { |
| super(codeOrigin); |
| this._name = name; |
| this._operands = operands; |
| if (!this._operands) |
| throw "Operands empty to Macro call " + name; |
| this._annotation = annotation; |
| } |
| |
| children() |
| { |
| return []; |
| } |
| |
| dump() |
| { |
| return " " + this.name + "(" + this.operands.map(function(v) { return v.dump() }).join(", ") + ")"; |
| } |
| |
| get name() |
| { |
| return this._name; |
| } |
| |
| get operands() |
| { |
| return this._operands; |
| } |
| |
| get annotation() |
| { |
| return this._annotation; |
| } |
| } |
| |
| function resetAST() |
| { |
| StructOffset.resetMappings(); |
| Sizeof.resetMappings(); |
| ConstExpr.resetMappings(); |
| Label.resetMappings(); |
| LocalLabel.resetMappings(); |
| Setting.resetMappings(); |
| } |
