Пример #1
0
def read(parser, prototype):
    parser = _State(parser)

    size = parser.stream.read_uleb128()

    if size == 0:
        return False

    if not parser.stream.check_data_available(size):
        errprint("File truncated")
        return False

    start = parser.stream.pos

    r = True

    r = r and _read_flags(parser, prototype)
    r = r and _read_counts_and_sizes(parser, prototype)
    r = r and _read_instructions(parser, prototype)
    r = r and _read_constants(parser, prototype)
    r = r and _read_debuginfo(parser, prototype)

    end = parser.stream.pos

    if r:
        assert end - start == size, "Incorrectly read: from {0} to {1} ({2}) instead of {3}".format(
            start, end, end - start, size
        )

    return r
Пример #2
0
def read(parser, prototype):
    parser = _State(parser)

    size = parser.stream.read_uleb128()

    if size == 0:
        return False

    if not parser.stream.check_data_available(size):
        errprint("File truncated")
        return False

    start = parser.stream.pos

    r = True

    r = r and _read_flags(parser, prototype)
    r = r and _read_counts_and_sizes(parser, prototype)
    r = r and _read_instructions(parser, prototype)
    r = r and _read_constants(parser, prototype)
    r = r and _read_debuginfo(parser, prototype)

    end = parser.stream.pos

    if r:
        assert end - start == size,                     \
            "Incorrectly read: from {0} to {1} ({2}) instead of {3}"\
            .format(start, end, end - start, size)

    return r
Пример #3
0
def _read_version(state, header):
    header.version = state.stream.read_byte()
    if header.version > _MAX_VERSION:
        errprint("Version {0}: propritary modifications", header.version)
        return False

    return True
Пример #4
0
def _read_flags(parser, prototype):
    flags = parser.stream.read_byte()
    bits = flags
    prototype.flags.has_ffi = bool(flags & FLAG_HAS_FFI)
    bits &= ~FLAG_HAS_FFI

    prototype.flags.has_iloop = bool(flags & FLAG_HAS_ILOOP)
    bits &= ~FLAG_HAS_ILOOP

    prototype.flags.has_jit = not (flags & FLAG_JIT_DISABLED)
    bits &= ~FLAG_JIT_DISABLED

    prototype.flags.has_sub_prototypes = bool(flags & FLAG_HAS_CHILD)
    bits &= ~FLAG_HAS_CHILD

    prototype.flags.is_variadic = bool(flags & FLAG_IS_VARIADIC)
    bits &= ~FLAG_IS_VARIADIC

    # errprint ("prototype.flags.has_ffi %d" % prototype.flags.has_ffi)
    # errprint ("prototype.flags.has_iloop %d" % prototype.flags.has_iloop)
    # errprint ("prototype.flags.has_jit %d" % prototype.flags.has_jit)
    # errprint ("prototype.flags.has_sub_prototypes %d" % prototype.flags.has_sub_prototypes)
    # errprint ("prototype.flags.is_variadic %d" % prototype.flags.is_variadic)
    
    if bits != 0:
        errprint("Unknown prototype flags: {0:08b}", bits)
        return False

    return True
Пример #5
0
def _read_version(state, header):
	header.version = state.stream.read_byte()

	if header.version > _MAX_VERSION:
		errprint("Version {0}: propritary modifications",
						header.version)
		return False

	return True
Пример #6
0
def _read_header(parser, header):
    if not ljd.rawdump.header.read(parser, header):
        errprint("Failed to read raw-dump header")
        return False

    if header.flags.is_big_endian:
        parser.stream.data_byteorder = 'big'
    else:
        parser.stream.data_byteorder = 'little'

    return True
Пример #7
0
def _read_header(parser, header):
	if not ljd.rawdump.header.read(parser, header):
		errprint("Failed to read raw-dump header")
		return False

	if header.flags.is_big_endian:
		parser.stream.data_byteorder = 'big'
	else:
		parser.stream.data_byteorder = 'little'

	return True
Пример #8
0
def _read_prototypes(state, prototypes):
	while not state.stream.eof():
		prototype = ljd.bytecode.prototype.Prototype()

		if not ljd.rawdump.prototype.read(state, prototype):
			if state.stream.eof():
				break
			else:
				errprint("Failed to read prototype")
				return False

		prototypes.append(prototype)

	return True
Пример #9
0
def _read_prototypes(state, prototypes):
    while not state.stream.eof():
        prototype = ljd.bytecode.prototype.Prototype()

        if not ljd.rawdump.prototype.read(state, prototype):
            if state.stream.eof():
                break
            else:
                errprint("Failed to read prototype")
                return False

        prototypes.append(prototype)

    return True
Пример #10
0
def _read_prototypes(state, prototypes):
    while not state.stream.eof():
        prototype = ljd.bytecode.prototype.Prototype()
        #print ("good rwsdump->parser->read_prototypes")

        if not ljd.rawdump.prototype.read(state, prototype):
            if state.stream.eof():
                break
            else:
                errprint("Failed to read prototype")
                return False
        # dump("prototype",prototype,0)
        prototypes.append(prototype)

    return True
Пример #11
0
def _read_flags(parser, header):
    bits = parser.stream.read_uleb128()

    header.flags.is_big_endian = bits & _FLAG_IS_BIG_ENDIAN
    bits &= ~_FLAG_IS_BIG_ENDIAN

    header.flags.is_stripped = bits & _FLAG_IS_STRIPPED
    bits &= ~_FLAG_IS_STRIPPED

    header.flags.has_ffi = bits & _FLAG_HAS_FFI
    bits &= ~_FLAG_HAS_FFI

    if bits != 0:
        errprint("Unknown flags set: {0:08b}", bits)
        return False

    return True
Пример #12
0
def _read_flags(parser, header):
	bits = parser.stream.read_uleb128()

	header.flags.is_big_endian = bits & _FLAG_IS_BIG_ENDIAN
	bits &= ~_FLAG_IS_BIG_ENDIAN

	header.flags.is_stripped = bits & _FLAG_IS_STRIPPED
	bits &= ~_FLAG_IS_STRIPPED

	header.flags.has_ffi = bits & _FLAG_HAS_FFI
	bits &= ~_FLAG_HAS_FFI

	if bits != 0:
		errprint("Unknown flags set: {0:08b}", bits)
		return False

	return True
Пример #13
0
def read(parser):
    global _MAP

    codeword = parser.stream.read_uint(4)

    opcode = codeword & 0xFF

    instruction_class = _MAP[opcode]

    if instruction_class is None:
        errprint("Warning: unknown opcode {0:08x}", opcode)
        instruction_class = instructions.UNKNW  # @UndefinedVariable

    instruction = instruction_class()

    if instruction_class.opcode != opcode:
        instruction.opcode = opcode

    _set_instruction_operands(parser, codeword, instruction)

    return instruction
Пример #14
0
def parse(filename):
    parser = _State()

    parser.stream.open(filename)

    header = ljd.rawdump.header.Header()

    r = True

    try:
        r = r and _read_header(parser, header)
        r = r and _read_prototypes(parser, parser.prototypes)
    except IOError as e:
        errprint("I/O error while reading dump: {0}", str(e))
        r = False

    if r and not parser.stream.eof():
        errprint("Stopped before whole file was read, something wrong")
        r = False

    if r and len(parser.prototypes) != 1:
        errprint("Invalid prototypes stack order")
        r = False

    parser.stream.close()

    if r:
        return header, parser.prototypes[0]
    else:
        return None, None
Пример #15
0
def parse(filename):
	parser = _State()

	parser.stream.open(filename)

	header = ljd.rawdump.header.Header()

	r = True

	try:
		r = r and _read_header(parser, header)
		r = r and _read_prototypes(parser, parser.prototypes)
	except IOError as e:
		errprint("I/O error while reading dump: {0}", str(e))
		r = False

	if r and not parser.stream.eof():
		errprint("Stopped before whole file was read, something wrong")
		r = False

	if r and len(parser.prototypes) != 1:
		errprint("Invalid prototypes stack order")
		r = False

	parser.stream.close()

	if r:
		return header, parser.prototypes[0]
	else:
		return None, None
Пример #16
0
def _read_flags(parser, header):
    bits = parser.stream.read_uleb128()

    header.flags.is_big_endian = bits & _FLAG_IS_BIG_ENDIAN
    bits &= ~_FLAG_IS_BIG_ENDIAN

    header.flags.is_stripped = bits & _FLAG_IS_STRIPPED
    bits &= ~_FLAG_IS_STRIPPED

    header.flags.has_ffi = bits & _FLAG_HAS_FFI
    bits &= ~_FLAG_HAS_FFI

    # zzw.20180714 pitch: flag value is according to parser.flag when parse proto, not by header.flags
    parser.flags.is_big_endian = header.flags.is_big_endian
    parser.flags.is_stripped = header.flags.is_stripped
    parser.flags.is_big_endian = header.flags.has_ffi

    if bits != 0:
        errprint("Unknown flags set: {0:08b}", bits)
        return False

    return True
Пример #17
0
def read(parser):
    global _MAP
    codeword = parser.stream.read_uint(4)

    # errprint ("codeword %08x" % codeword, file=sys.stderr)
    opcode = codeword & 0xFF
    # errprint ("opcode %x" % opcode)

    instruction_class = _MAP[opcode]

    if instruction_class is None:
        errprint("Warning: unknown opcode {0:08x}", opcode)
        instruction_class = instructions.UNKNW  # @UndefinedVariable #zzw.20180714

    instruction = instruction_class()

    if instruction_class.opcode != opcode:
        instruction.opcode = opcode

    # errprint ("instruction.opcode %x name %s" % (instruction.opcode,instruction.name))
    _set_instruction_operands(parser, codeword, instruction)

    return instruction
Пример #18
0
def _read_flags(parser, prototype):
    bits = parser.stream.read_byte()

    prototype.flags.has_ffi = bool(bits & FLAG_HAS_FFI)
    bits &= ~FLAG_HAS_FFI

    prototype.flags.has_iloop = bool(bits & FLAG_HAS_ILOOP)
    bits &= ~FLAG_HAS_ILOOP

    prototype.flags.has_jit = not (bits & FLAG_JIT_DISABLED)
    bits &= ~FLAG_JIT_DISABLED

    prototype.flags.has_sub_prototypes = bool(bits & FLAG_HAS_CHILD)
    bits &= ~FLAG_HAS_CHILD

    prototype.flags.is_variadic = bool(bits & FLAG_IS_VARIADIC)
    bits &= ~FLAG_IS_VARIADIC

    if bits != 0:
        errprint("Unknown prototype flags: {0:08b}", bits)
        return False

    return True
Пример #19
0
def _read_version(state, header):
    header.version = state.stream.read_byte()
    if header.version != gconfig.gBCVersion:
        errprint("header.version {0} is not equals to gconfig.gBCVersion {1}", header.version, gconfig.gBCVersion)
        errprint("please modify gBCVersion in gconfig.py to make sure gconfig.gBCVersion == header.version")
        return False

    if header.version > _MAX_VERSION:
        errprint("Version {0}: propritary modifications",
                        header.version)
        return False

    return True
Пример #20
0
def _check_magic(state):
    if state.stream.read_bytes(3) != _MAGIC:
        errprint("Invalid magic, not a LuaJIT format")
        return False

    return True
Пример #21
0
def _check_magic(state):
	if state.stream.read_bytes(3) != _MAGIC:
		errprint("Invalid magic, not a LuaJIT format")
		return False

	return True