* Copyright (C) 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";
function SPIRV(json) {
let result = {
ops: {},
kinds: {}
}
let composites = new Map();
let ids = new Map();
for (let kind of json.operand_kinds) {
switch (kind.category) {
case "BitEnum":
case "ValueEnum":
let enumerants = { category: kind.category };
for (let enumerant of kind.enumerants) {
enumerants[enumerant.enumerant] = enumerant;
}
result.kinds[kind.kind] = enumerants;
break;
case "Composite":
composites.set(kind.kind, kind);
break;
case "Id":
ids.set(kind.kind, kind);
break;
}
}
function matchType(operandInfoKind, operand) {
switch (operandInfoKind) {
case "IdResultType":
case "IdResult":
case "IdRef":
case "IdScope":
case "IdMemorySemantics":
case "LiteralExtInstInteger":
if (typeof operand != "number")
throw new Error("Operand needs to be a number");
if ((operand >>> 0) != operand)
throw new Error("Operand needs to fit in an unsigned int");
return;
case "LiteralInteger":
if (typeof operand != "number")
throw new Error("Operand needs to be a number");
if ((operand | 0) != operand)
throw new Error("Operand needs to fit in an int");
return;
case "LiteralString":
if (typeof operand != "string")
throw new Error("Operand needs to be a string");
return;
case "LiteralContextDependentNumber":
case "LiteralSpecConstantOpInteger":
if (typeof operand != "number")
throw new Error("Operand needs to be a number");
if ((operand >>> 0) != operand && (operand | 0) != operand)
throw new Error("Operand needs to fit in an unsigned int or an int.");
return;
}
let kind = result.kinds[operandInfoKind];
if (kind) {
if (operand instanceof Array) {
if (kind.category != "BitEnum")
throw new Error("Passing an array to a " + kind.category + " operand");
for (let operandItem of operand) {
if (kind[operandItem.enumerant] != operandItem)
throw new Error("" + operandItem.enumerant + " is not a member of " + operandInfoKind);
}
return;
}
if (kind[operand.enumerant] != operand)
throw new Error("" + operand.enumerant + " is not a member of " + operandInfoKind);
return;
}
throw new Error("Unknown type: " + operandInfoKind);
}
class OperandChecker {
constructor(operandInfos)
{
this._operandInfos = operandInfos || [];
this._operandIndex = 0;
this._operandInfoIndex = 0;
this._parameters = [];
}
_isStar(operandInfo)
{
switch (operandInfo.kind) {
case "LiteralContextDependentNumber":
case "LiteralSpecConstantOpInteger":
return true;
}
return operandInfo.quantifier && operandInfo.quantifier == "*";
}
nextComparisonType(operand)
{
if (this._operandInfoIndex >= this._operandInfos.length)
throw new Error("Specified operand does not correspond to any that the instruction expects.");
let operandInfo = this._operandInfos[this._operandInfoIndex];
let isStar = this._isStar(operandInfo);
if (this._parameters.length != 0) {
let result = this._parameters[0];
this._parameters.splice(0, 1);
++this._operandIndex;
if (this._parameters.length == 0 && !isStar)
++this._operandInfoIndex;
return result;
}
let composite = composites.get(operandInfo.kind);
if (composite) {
for (let base of composite.bases)
this._parameters.push(base);
nextComparisonType(operand);
return;
}
let kind = result.kinds[operandInfo.kind];
if (kind) {
let enumerant = kind[operand.enumerant];
if (enumerant) {
let parameters = enumerant.parameters;
if (parameters) {
for (let parameter of parameters) {
this._parameters.push(parameter.kind);
}
++this._operandIndex;
return operandInfo.kind;
}
}
}
++this._operandIndex;
if (!isStar)
++this._operandInfoIndex;
return operandInfo.kind;
}
check(operand)
{
matchType(this.nextComparisonType(operand), operand);
}
finalize()
{
if (this._parameters.length != 0)
throw new Error("Operand not specified for parameter.");
for (let i = this._operandInfoIndex; i < this._operandInfos.length; ++i) {
let operandInfo = this._operandInfos[i];
let quantifier = operandInfo.quantifier;
if (quantifier != "?" && !this._isStar(operandInfo))
throw new Error("Did not specify operand " + i + " to instruction.");
}
}
}
for (let instruction of json.instructions) {
if (!instruction.opname.startsWith("Op"))
continue;
let attributeName = instruction.opname.substring(2);
result.ops[attributeName] = class {
constructor(...operands)
{
let operandChecker = new OperandChecker(instruction.operands);
for (let operand of operands)
operandChecker.check(operand);
operandChecker.finalize();
this._operands = operands;
}
get operands()
{
return this._operands;
}
get opname()
{
return instruction.opname;
}
get opcode()
{
return instruction.opcode;
}
get operandInfo()
{
return instruction.operands;
}
get storageSize()
{
let result = 1;
for (let operand of this.operands) {
if (typeof operand == "number")
++result;
else if (typeof operand == "string")
result += (((operand.length + 1) + 3) / 4) | 0;
else
++result;
}
return result;
}
get largestId()
{
let maximumId = 0;
let operandChecker = new OperandChecker(this.operandInfo);
for (let operand of this.operands) {
let type = operandChecker.nextComparisonType(operand);
let idType = ids.get(type);
if (idType)
maximumId = Math.max(maximumId, operand);
}
return maximumId;
}
}
}
return result;
}
class SPIRVAssembler {
constructor()
{
this._largestId = 0;
this._size = 5;
this._storage = new Uint32Array(this.size);
this.storage[0] = 0x07230203;
this.storage[1] = 0x00010000;
this.storage[2] = 0x574B0000;
this.storage[3] = 0;
this.storage[4] = 0;
}
append(op)
{
this._largestId = Math.max(this._largestId, op.largestId);
let deltaStorageSize = op.storageSize;
if (this.size + deltaStorageSize > this.storage.length) {
let newStorageSize = (this.size + deltaStorageSize) * 1.5;
let newStorage = new Uint32Array(newStorageSize);
for (let i = 0; i < this.size; ++i)
newStorage[i] = this.storage[i];
this._storage = newStorage;
}
if ((deltaStorageSize & 0xFFFF) != deltaStorageSize || (op.opcode & 0xFFFF) != op.opcode)
throw new Error("Out of bounds!");
this.storage[this.size] = ((deltaStorageSize & 0xFFFF) << 16) | (op.opcode & 0xFFFF);
++this._size;
if (deltaStorageSize <= op.operands.size)
throw new Error("The storage size must be greater than the number of parameters");
for (let i = 0; i < op.operands.length; ++i) {
let operand = op.operands[i];
if (typeof operand == "number") {
this.storage[this.size] = operand;
++this._size;
} else if (typeof operand == "string") {
let word = 0;
for (let j = 0; j < operand.length + 1; ++j) {
let charCode;
if (j < operand.length)
charCode = operand.charCodeAt(j);
else
charCode = 0;
if (charCode > 0xFF)
throw new Error("Non-ASCII strings don't work yet");
switch (j % 4) {
case 0:
word |= charCode;
break;
case 1:
word |= (charCode << 8);
break;
case 2:
word |= (charCode << 16);
break;
case 3:
word |= (charCode << 24);
this.storage[this.size + ((j / 4) | 0)] = word;
word = 0;
break;
}
}
if ((operand.length % 4) != 0)
this.storage[this.size + (((operand.length + 1) / 4) | 0)] = word;
this._size += (((operand.length + 1) + 3) / 4) | 0;
} else {
this.storage[this.size] = operand.value;
++this._size;
}
}
}
get size()
{
return this._size;
}
get storage()
{
return this._storage;
}
get result()
{
this.storage[3] = this._largestId + 1;
return this.storage.slice(0, this.size);
}
}
