from opcodes import *
import numpy as np
import struct as stc
class ParseFlags:
def __init__(
self,
wast_path,
wasm_path,
as_path,
disa_path,
out_path,
dbg,
unval,
memdump,
idxspc,
run,
metric,
gas,
entry,
):
self.wast_path = wast_path
self.wasm_path = wasm_path
self.as_path = as_path
self.disa_path = disa_path
self.out_path = out_path
self.dbg = dbg
self.unval = unval
self.memdump = memdump
self.idxspc = idxspc
self.run = run
self.metric = metric
self.gas = gas
self.entry = entry
# pretty print
class Colors:
purple = "\033[95m"
blue = "\033[94m"
green = "\033[92m"
yellow = "\033[93m"
red = "\033[91m"
grey = "\033[1;37m"
darkgrey = "\033[1;30m"
cyan = "\033[1;36m"
ENDC = "\033[0m"
BOLD = "\033[1m"
UNDERLINE = "\033[4m"
def LEB128UnsignedDecode(bytelist):
result = 0
shift = 0
for byte in bytelist:
result |= (byte & 0x7F) << shift
if (byte & 0x80) == 0:
break
shift += 7
return result
def LEB128SignedDecode(bytelist):
result = 0
shift = 0
for byte in bytelist:
result |= (byte & 0x7F) << shift
last_byte = byte
shift += 7
if (byte & 0x80) == 0:
break
if last_byte & 0x40:
result |= -(1 << shift)
return result
def LEB128UnsignedEncode(int_val):
if int_val < 0:
raise Exception("value must not be negative")
elif int_val == 0:
return bytes([0])
byte_array = bytearray()
while int_val:
byte = int_val & 0x7F
byte_array.append(byte | 0x80)
int_val >>= 7
byte_array[-1] ^= 0x80
return byte_array
def LEB128SignedEncode(int_val):
byte_array = bytearray()
while True:
byte = int_val & 0x7F
byte_array.append(byte | 0x80)
int_val >>= 7
if (int_val == 0 and byte & 0x40 == 0) or (
int_val == -1 and byte & 0x40
):
byte_array[-1] ^= 0x80
break
return byte_array
# @DEVI-FIXME-MVP-only-we currently inly support consts and get_global
# interprets the init-exprs
def init_interpret(expr):
offset = 0
byte, offset, dummy = Read(expr, offset, "uint8")
const = int()
if byte == 65:
# @DEVI-FIXME-the spec says varint32, obviously we are not doing that
# since it will return neg values which are meningless and break things
const, offset, dummy = Read(expr, offset, "varuint32")
elif byte == 66:
const, offset, dummy = Read(expr, offset, "varint64")
elif byte == 67:
const, offset, dummy = Read(expr, offset, "uint32")
elif byte == 68:
const, offset, dummy = Read(expr, offset, "uint64")
elif byte == 35:
pass
else:
raise Exception(
Colors.red + "illegal opcode for an MVP init expr." + Colors.ENDC
)
block_end, offset, dummy = Read(expr, offset, "uint8")
if block_end != 11:
raise Exception(
Colors.red + "init expr has no block end." + Colors.ENDC
)
return const
# reads different-typed values from a byte array, takes in the bytearray, the
# current offset the read should be performed from and the kind of value that
# should be read. returns the read value as a decimal number, the updated
# offset and the number of bytes read
def Read(section_byte, offset, kind):
operand = []
return_list = int()
read_bytes = 0
if (
kind == "varuint1"
or kind == "varuint7"
or kind == "varuint32"
or kind == "varuint64"
):
while True:
byte = int(section_byte[offset])
read_bytes += 1
offset += 1
operand.append(byte)
if byte == 0x80:
pass
elif byte & 0x80 != 0:
pass
else:
# we have read the last byte of the operand
break
return_list = LEB128UnsignedDecode(operand)
# operand = []
elif (
kind == "uint8"
or kind == "uint16"
or kind == "uint32"
or kind == "uint64"
):
byte = section_byte[offset : offset + TypeDic[kind]]
read_bytes += TypeDic[kind]
offset += TypeDic[kind]
operand.append(byte)
return_list = int.from_bytes(
operand[0], byteorder="little", signed=False
)
# operand = []
elif (
kind == "varint1"
or kind == "varint7"
or kind == "varint32"
or kind == "varint64"
):
while True:
byte = int(section_byte[offset])
read_bytes += 1
offset += 1
operand.append(byte)
# @DEVI-what happens when we decode a 56-bit value?
if byte == 0x80 or byte == 0xFF:
pass
elif byte & 0x80 != 0:
pass
else:
# we have read the lasy byte of the operand
break
return_list = LEB128SignedDecode(operand)
# operand = []
return return_list, offset, read_bytes
def ror(val, type_length, rot_size):
rot_size_rem = rot_size % type_length
return ((val >> rot_size_rem) & (2 ** type_length - 1)) | (
(val & (2 ** rot_size_rem - 1)) << (type_length - rot_size_rem)
)
def rol(val, type_length, rot_size):
rot_size_rem = rot_size % type_length
return ((val << rot_size_rem) & (2 ** type_length - 1)) | (
(
val
& (
(2 ** type_length - 1)
- (2 ** (type_length - rot_size_rem) - 1)
)
)
>> (type_length - rot_size_rem)
)
# @DEVI-these are here because i wanted to test them to make sure what i thik is
# happening is really happening
def reinterpretf32toi32(val):
return stc.unpack("i", stc.pack("f", val))[0]
def reinterpretf64toi64(val):
return stc.unpack("Q", stc.pack("d", val))[0]
def reinterpreti32tof32(val):
return stc.unpack("f", stc.pack("i", val))[0]
def reinterpreti64tof64(val):
return stc.unpack("d", stc.pack("Q", val))[0]
# @DEVI-FIXME
def clz(val, _type):
cnt = int()
if _type == "uint32":
# bits = np.uint32(val)
power = 31
while power > -1:
if val & 2 ** power == 0:
cnt += 1
else:
break
power -= 1
elif _type == "uint64":
# bits = bin(np.uint64(val))
power = 63
while power > -1:
if val & 2 ** power == 0:
cnt += 1
else:
break
power -= 1
else:
raise Exception(
Colors.red + "unsupported type passed to clz." + Colors.ENDC
)
return cnt
# @DEVI-FIXME
def ctz(val, _type):
cnt = int()
power = int()
if _type == "uint32":
# bits = np.uint32(val)
while power < 32:
if val & 2 ** power == 0:
cnt += 1
else:
break
power += 1
elif _type == "uint64":
# bits = bin(np.uint64(val))
while power < 64:
if val & 2 ** power == 0:
cnt += 1
else:
break
power += 1
else:
raise Exception(
Colors.red + "unsupported type passed to ctz." + Colors.ENDC
)
return cnt
# @DEVI-FIXME
def pop_cnt(val, _type):
cnt = int()
power = int()
if _type == "uint32":
# bits = np.uint32(val)
while power < 32:
if val & 2 ** power != 0:
cnt += 1
power += 1
elif _type == "uint64":
# bits = bin(np.uint64(val))
while power < 64:
if val & 2 ** power != 0:
cnt += 1
power += 1
else:
raise Exception(
Colors.red + "unsupported type passed to pop_cnt." + Colors.ENDC
)
return cnt
def gen_label(label_stack):
counter += 1
label_stack.append(counter)
def dumpprettysections(sections_list, width, section_name):
line_counter = 0
str_list = []
module_counter = 0
section_offset = 0
for sections in sections_list:
print(
Colors.cyan
+ Colors.BOLD
+ "module "
+ repr(module_counter)
+ Colors.ENDC
)
for section in sections.section_list:
if section_name == "":
pass
else:
if section_name != SectionID[section[0]]:
continue
print(
Colors.green
+ Colors.BOLD
+ SectionID[section[0]]
+ " section"
+ Colors.ENDC
)
# print(Colors.green + "length: " + Colors.blue + section[1] + Colors.ENDC)
print(
Colors.green
+ "length: "
+ Colors.blue
+ repr(section[2])
+ Colors.ENDC
)
print(
Colors.green
+ "is custom section: "
+ Colors.blue
+ repr(section[3])
+ Colors.ENDC
)
print(
Colors.green
+ "name length: "
+ Colors.blue
+ repr(section[4])
+ Colors.ENDC
)
# print(section[5])
# print(''.join(chr(char) for char in section[5]))
# print( ''.join([chr(char) for char in section[5]]))
if type(section[5]) == list:
print(
Colors.green
+ "name: "
+ Colors.blue
+ "".join([chr(char) for char in section[5]])
+ Colors.ENDC
)
else:
print(
Colors.green
+ "name: "
+ Colors.blue
+ section[5]
+ Colors.ENDC
)
print("\t", end="")
for offset in range(0, width):
if offset <= 15:
print(
Colors.blue + hex(offset) + " " + Colors.ENDC, end=""
)
else:
print(
Colors.blue + hex(offset) + " " + Colors.ENDC, end=""
)
print()
print(
Colors.blue
+ Colors.BOLD
+ hex(section_offset)
+ "\t"
+ Colors.ENDC,
end="",
)
for byte in section[6]:
if line_counter == width:
section_offset += width
# print("\t\t", end="")
line_counter = 0
for char in str_list:
print(Colors.green + "|" + Colors.ENDC, end="")
if ord(char) < 32 or ord(char) > 127:
print(" ", end="")
else:
print(char, end="")
str_list = []
print()
print(
Colors.blue
+ Colors.BOLD
+ hex(section_offset)
+ "\t"
+ Colors.ENDC,
end="",
)
print(format(byte, "02x") + " ", end="")
str_list.append(chr(byte))
line_counter += 1
# print(" ", end="")
for i in range(0, width - line_counter):
print(" ", end="")
for char in str_list:
if ord(char) < 32:
print(" ", end="")
else:
print(char, end="")
print(Colors.green + "|" + Colors.ENDC, end="")
str_list = []
line_counter = 0
section_offset = 0
print()
str_list = []
line_counter = 0
module_counter += 1
section_offset = 0
def popcnt32(r1):
temp = r1
temp = (temp & 0x55555555) + ((temp >> 1) & 0x55555555)
temp = (temp & 0x33333333) + ((temp >> 2) & 0x33333333)
temp = (temp & 0x0F0F0F0F) + ((temp >> 4) & 0x0F0F0F0F)
temp = (temp & 0x00FF00FF) + ((temp >> 8) & 0x00FF00FF)
temp = (temp & 0x0000FFFF) + ((temp >> 16) & 0x0000FFFF)
return temp
def popcnt64(r1):
temp = r1
temp = (temp & 0x5555555555555555) + ((temp >> 1) & 0x5555555555555555)
temp = (temp & 0x3333333333333333) + ((temp >> 2) & 0x3333333333333333)
temp = (temp & 0x0F0F0F0F0F0F0F0F) + ((temp >> 4) & 0x0F0F0F0F0F0F0F0F)
temp = (temp & 0x00FF00FF00FF00FF) + ((temp >> 8) & 0x00FF00FF00FF00FF)
temp = (temp & 0x0000FFFF0000FFFF) + ((temp >> 16) & 0x0000FFFF0000FFFF)
temp = (temp & 0x00000000FFFFFFFF) + ((temp >> 32) & 0x00000000FFFFFFFF)
return temp
def clz32(r1):
if r1 == 0:
return 32
temp_r1 = r1
n = 0
if temp_r1 & 0xFFFF0000 == 0:
n += 16
temp_r1 = temp_r1 << 16
if temp_r1 & 0xFF000000 == 0:
n += 8
temp_r1 = temp_r1 << 8
if temp_r1 & 0xF0000000 == 0:
n += 4
temp_r1 = temp_r1 << 4
if temp_r1 & 0xC0000000 == 0:
n += 2
temp_r1 = temp_r1 << 2
if temp_r1 & 0x8000000 == 0:
n += 1
return n
def clz64(r1):
if r1 == 0:
return 64
temp_r1 = r1
n = 0
if temp_r1 & 0xFFFFFFFF00000000 == 0:
n += 32
temp_r1 = temp_r1 << 32
if temp_r1 & 0xFFFF000000000000 == 0:
n += 16
temp_r1 == temp_r1 << 16
if temp_r1 & 0xFF00000000000000 == 0:
n += 8
temp_r1 = temp_r1 << 8
if temp_r1 & 0xF000000000000000 == 0:
n += 4
temp_r1 = temp_r1 << 4
if temp_r1 & 0xC000000000000000 == 0:
n += 2
temp_r1 = temp_r1 << 2
if temp_r1 & 0x8000000000000000 == 0:
n += 1
return n
def ctz32(r1):
if r1 == 0:
return 32
temp_r1 = r1
n = 0
if temp_r1 & 0x0000FFFF == 0:
n += 16
temp_r1 = temp_r1 >> 16
if temp_r1 & 0x000000FF == 0:
n += 8
temp_r1 = temp_r1 >> 8
if temp_r1 & 0x0000000F == 0:
n += 4
temp_r1 = temp_r1 >> 4
if temp_r1 & 0x00000003 == 0:
n += 2
temp_r1 = temp_r1 >> 2
if temp_r1 & 0x00000001 == 0:
n += 1
return n
def ctz64(r1):
if r1 == 0:
return 64
temp_r1 = r1
n = 0
if temp_r1 & 0x00000000FFFFFFFF == 0:
n += 32
temp_r1 = temp_r1 >> 32
if temp_r1 & 0x000000000000FFFF == 0:
n += 16
temp_r1 = temp_r1 >> 16
if temp_r1 & 0x00000000000000FF == 0:
n += 8
temp_r1 = temp_r1 >> 8
if temp_r1 & 0x000000000000000F == 0:
n += 4
temp_r1 = temp_r1 >> 4
if temp_r1 & 0x0000000000000003 == 0:
n += 2
temp_r1 = temp_r1 >> 2
if temp_r1 & 0x0000000000000001 == 0:
n += 1
return n