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])),