def write(self, start_addr, num_bytes, value):
if self.debug.enabled("mem"):
print ':: WR.MEM[%s] = %s' % (pad_hex(start_addr), pad_hex(value)),
block_addr = self.block_mask & start_addr
block_addr = hint(block_addr, promote=True)
block_mem = self.get_block_mem(block_addr)
block_mem.write(start_addr & self.addr_mask, num_bytes, value)
def read(self, start_addr, num_bytes):
assert 0 < num_bytes <= 4
word = start_addr >> 2
byte = start_addr & 0b11
if self.debug.enabled("mem"):
print ':: RD.MEM[%s] = ' % pad_hex(start_addr),
if self.debug.enabled("memcheck"):
self.bounds_check(start_addr, 'RD')
value = 0
if num_bytes == 4: # TODO: byte should only be 0 (only aligned)
value = self.data[word]
elif num_bytes == 2: # TODO: byte should only be 0, 1, 2, not 3
mask = 0xFFFF << (byte * 8)
value = (self.data[word] & mask) >> (byte * 8)
elif num_bytes == 1:
mask = 0xFF << (byte * 8)
value = (self.data[word] & mask) >> (byte * 8)
else:
raise Exception('Invalid num_bytes: %d!' % num_bytes)
if self.debug.enabled("mem"):
print '%s' % pad_hex(value),
return value
def write(self, start_addr, num_bytes, value):
assert 0 < num_bytes <= 4
start_addr = r_uint(start_addr)
value = r_uint(value)
word = start_addr >> 2
byte = start_addr & 0b11
if self.debug.enabled("memcheck") and not self.suppress_debug:
self.bounds_check(start_addr, 'WR')
if num_bytes == 4: # TODO: byte should only be 0 (only aligned)
pass # no masking needed
elif num_bytes == 2: # TODO: byte should only be 0, 1, 2, not 3
mask = ~(0xFFFF << (byte * 8)) & r_uint(0xFFFFFFFF)
value = ( widen( self.data[ word ] ) & mask ) \
| ( (value & 0xFFFF) << (byte * 8) )
elif num_bytes == 1:
mask = ~(0xFF << (byte * 8)) & r_uint(0xFFFFFFFF)
value = ( widen( self.data[ word ] ) & mask ) \
| ( (value & 0xFF ) << (byte * 8) )
else:
raise Exception('Invalid num_bytes: %d!' % num_bytes)
if self.debug.enabled("mem") and not self.suppress_debug:
print ':: WR.MEM[%s] = %s' % (pad_hex(start_addr), pad_hex(value)),
self.data[word] = r_uint32(value)
def write( self, start_addr, num_bytes, value ):
assert 0 < num_bytes <= 4
word = start_addr >> 2
byte = start_addr & 0b11
if self.debug.enabled( "memcheck" ):
self.bounds_check( start_addr, 'WR' )
if num_bytes == 4: # TODO: byte should only be 0 (only aligned)
pass # no masking needed
elif num_bytes == 2: # TODO: byte should only be 0, 1, 2, not 3
mask = ~(0xFFFF << (byte * 8)) & 0xFFFFFFFF
value = ( widen( self.data[ word ] ) & mask ) \
| ( (value & 0xFFFF) << (byte * 8) )
elif num_bytes == 1:
mask = ~(0xFF << (byte * 8)) & 0xFFFFFFFF
value = ( widen( self.data[ word ] ) & mask ) \
| ( (value & 0xFF ) << (byte * 8) )
else:
raise Exception('Invalid num_bytes: %d!' % num_bytes)
if self.debug.enabled( "mem" ):
print ':: WR.MEM[%s] = %s' % ( pad_hex( start_addr ),
pad_hex( value ) ),
self.data[ word ] = r_uint32( value )
def read( self, start_addr, num_bytes ):
assert 0 < num_bytes <= 4
word = start_addr >> 2
byte = start_addr & 0b11
if self.debug.enabled( "mem" ):
print ':: RD.MEM[%s] = ' % pad_hex( start_addr ),
if self.debug.enabled( "memcheck" ):
self.bounds_check( start_addr, 'RD' )
value = 0
if num_bytes == 4: # TODO: byte should only be 0 (only aligned)
value = widen( self.data[ word ] )
elif num_bytes == 2: # TODO: byte should only be 0, 1, 2, not 3
mask = 0xFFFF << (byte * 8)
value = ( widen( self.data[ word ] ) & mask) >> (byte * 8)
elif num_bytes == 1:
mask = 0xFF << (byte * 8)
value = ( widen( self.data[ word ] ) & mask) >> (byte * 8)
else:
raise Exception('Invalid num_bytes: %d!' % num_bytes)
if self.debug.enabled( "mem" ):
print '%s' % pad_hex( value ),
return value
def bounds_check(self, addr):
# check if the accessed data is larger than the memory size
if addr > self.size:
print "WARNING: accessing larger address than memory size. " + \
"addr=%s size=%s" % ( pad_hex( addr ), pad_hex( self.size ) )
if addr == 0:
print "WARNING: writing null pointer!"
raise Exception()
def write(self, start_addr, num_bytes, value):
if self.debug.enabled("memcheck"):
self.bounds_check(start_addr)
if self.debug.enabled("mem"):
print ':: WR.MEM[%s] = %s' % (pad_hex(start_addr), pad_hex(value)),
for i in range(num_bytes):
self.data[start_addr + i] = chr(value & 0xFF)
value = value >> 8
def write( self, start_addr, num_bytes, value ):
if self.debug.enabled( "mem" ):
print ':: WR.MEM[%s] = %s' % ( pad_hex( start_addr ),
pad_hex( value ) ),
block_addr = self.block_mask & start_addr
block_addr = hint( block_addr, promote=True )
block_mem = self.get_block_mem( block_addr )
block_mem.write( start_addr & self.addr_mask, num_bytes, value )
def bounds_check( self, addr ):
# check if the accessed data is larger than the memory size
if addr > self.size:
print "WARNING: accessing larger address than memory size. " + \
"addr=%s size=%s" % ( pad_hex( addr ), pad_hex( self.size ) )
if addr == 0:
print "WARNING: writing null pointer!"
raise Exception()
def write( self, start_addr, num_bytes, value ):
if self.debug.enabled( "memcheck" ):
self.bounds_check( start_addr )
if self.debug.enabled( "mem" ):
print ':: WR.MEM[%s] = %s' % ( pad_hex( start_addr ),
pad_hex( value ) ),
for i in range( num_bytes ):
self.data[ start_addr + i ] = chr(value & 0xFF)
value = value >> 8
def read(self, start_addr, num_bytes):
if self.debug.enabled("mem"):
print ':: RD.MEM[%s] = ' % pad_hex(start_addr),
block_addr = self.block_mask & start_addr
block_addr = hint(block_addr, promote=True)
block_mem = self.get_block_mem(block_addr)
value = block_mem.read(start_addr & self.addr_mask, num_bytes)
if self.debug.enabled("mem"):
print '%s' % pad_hex(value),
return value
def read( self, start_addr, num_bytes ):
if self.debug.enabled( "mem" ):
print ':: RD.MEM[%s] = ' % pad_hex( start_addr ),
block_addr = self.block_mask & start_addr
block_addr = hint( block_addr, promote=True )
block_mem = self.get_block_mem( block_addr )
value = block_mem.read( start_addr & self.addr_mask, num_bytes )
if self.debug.enabled( "mem" ):
print '%s' % pad_hex( value ),
return value
def read( self, start_addr, num_bytes ):
if self.debug.enabled( "memcheck" ):
self.bounds_check( start_addr )
value = 0
if self.debug.enabled( "mem" ):
print ':: RD.MEM[%s] = ' % pad_hex( start_addr ),
for i in range( num_bytes-1, -1, -1 ):
value = value << 8
value = value | ord( self.data[ start_addr + i ] )
if self.debug.enabled( "mem" ):
print '%s' % pad_hex( value ),
return value
def read(self, start_addr, num_bytes):
if self.debug.enabled("memcheck"):
self.bounds_check(start_addr)
value = 0
if self.debug.enabled("mem"):
print ':: RD.MEM[%s] = ' % pad_hex(start_addr),
for i in range(num_bytes - 1, -1, -1):
value = value << 8
value = value | ord(self.data[start_addr + i])
if self.debug.enabled("mem"):
print '%s' % pad_hex(value),
return value
def bounds_check( self, addr, x ):
# check if the accessed data is larger than the memory size
if addr > self.size:
print ("WARNING: %s accessing larger address than memory size. "
"addr=%s size=%s") % ( x, pad_hex( addr ), pad_hex( self.size ) )
raise Exception()
if addr == 0:
print "WARNING: accessing null pointer!"
raise Exception()
# Special write checks
if x == 'WR' and addr < self.data_section:
print ("WARNING: %s writing address below .data section!!!. "
"addr=%s size=%s") % ( x, pad_hex( addr ), pad_hex( self.data_section ) )
raise Exception()
def print_regs(self, per_row=6):
for c in xrange(0, self.num_regs, per_row):
str = ""
for r in xrange(c, min(self.num_regs, c + per_row)):
str += "%s:%s " % (pad(
"%d" % r, 2), pad_hex(self.regs[r], len=(self.nbits / 4)))
print str
def __getitem__( self, idx ):
if self.debug.enabled( "rf" ):
print ':: RD.RF[%s] = %s' % (
pad( "%d" % idx, 2 ),
pad_hex( self.regs[idx],
len=self.debug_nchars ) ),
return self.regs[idx]
def _set_item( self, idx, value ):
self.regs[idx] = value
if self.debug.enabled( "rf" ):
print ':: WR.RF[%s] = %s' % (
pad( "%d" % idx, 2 ),
pad_hex( self.regs[idx],
len=self.debug_nchars ) ),
def print_regs( self, per_row=6 ):
for c in xrange( 0, self.num_regs, per_row ):
str = ""
for r in xrange( c, min( self.num_regs, c+per_row ) ):
str += "%s:%s " % ( pad( "%d" % r, 2 ),
pad_hex( self.regs[r] ) )
print str
def _set_item_const_zero(self, idx, value):
if idx != 0:
self.regs[idx] = value
if self.debug.enabled("rf"):
print ':: WR.RF[%s] = %s' % (pad("%d" % idx, 2),
pad_hex(self.regs[idx],
len=self.debug_nchars)),
def _set_item_const_zero( self, idx, value ):
if idx != 0:
self.regs[idx] = value
if self.debug.enabled( "rf" ):
print ':: WR.RF[%s] = %s' % (
pad( "%d" % idx, 2 ),
pad_hex( self.regs[idx] ) ),
def bounds_check(self, addr, x):
# check if the accessed data is larger than the memory size
if addr > self.size:
print(
"WARNING: %s accessing larger address than memory size. "
"addr=%s size=%s") % (x, pad_hex(addr), pad_hex(self.size))
raise Exception()
if addr == 0:
print "WARNING: accessing null pointer!"
raise Exception()
# Special write checks
if x == 'WR' and addr < self.data_section:
print(
"WARNING: %s writing address below .data section!!!. "
"addr=%s size=%s") % (x, pad_hex(addr),
pad_hex(self.data_section))
raise Exception()
def write(self, start_addr, num_bytes, value):
assert 0 < num_bytes <= 4
word = start_addr >> 2
byte = start_addr & 0b11
if self.debug.enabled("memcheck"):
self.bounds_check(start_addr, 'WR')
if num_bytes == 4: # TODO: byte should only be 0 (only aligned)
self.data[word] = value
elif num_bytes == 2: # TODO: byte should only be 0, 1, 2, not 3
mask = ~(0xFFFF << (byte * 8)) & 0xFFFFFFFF
value = (self.data[word] & mask) | ((value & 0xFFFF) << (byte * 8))
elif num_bytes == 1:
mask = ~(0xFF << (byte * 8)) & 0xFFFFFFFF
value = (self.data[word] & mask) | ((value & 0xFF) << (byte * 8))
else:
raise Exception('Invalid num_bytes: %d!' % num_bytes)
if self.debug.enabled("mem"):
print ':: WR.MEM[%s] = %s' % (pad_hex(start_addr), pad_hex(value)),
self.data[word] = value
def __getitem__(self, idx):
if self.debug.enabled("rf"):
print ':: RD.RF[%s] = %s' % (pad("%d" % idx,
2), pad_hex(self.regs[idx])),
return self.regs[idx]
def _set_item(self, idx, value):
self.regs[idx] = value
if self.debug.enabled("rf"):
print ':: WR.RF[%s] = %s' % (pad("%d" % idx,
2), pad_hex(self.regs[idx])),
