/* May need to disable updating of memory & condition codes */ static void update_state(bool_t update_mem, bool_t update_cc) { /* Writeback(s): If either register is REG_NONE, write will have no effect . Order of two writes determines semantics of popl %esp. According to ISA, %esp will get popped value */ if (wb_destE != REG_NONE) { sim_log("Writeback: Wrote 0x%x to register %s\n", wb_valE, reg_name(wb_destE)); set_reg_val(reg, wb_destE, wb_valE); } if (wb_destM != REG_NONE) { sim_log("Writeback: Wrote 0x%x to register %s\n", wb_valM, reg_name(wb_destM)); set_reg_val(reg, wb_destM, wb_valM); } /* Memory write */ if (mem_write && !update_mem) { sim_log("Disabled write of 0x%x to address 0x%x\n", mem_data, mem_addr); } if (update_mem && mem_write) { if (!set_word_val(mem, mem_addr, mem_data)) { sim_log("Couldn't write to address 0x%x\n", mem_addr); } else { sim_log("Wrote 0x%x to address 0x%x\n", mem_data, mem_addr); #ifdef HAS_GUI if (gui_mode) { if (mem_addr % 4 != 0) { /* Just did a misaligned write. Need to display both words */ word_t align_addr = mem_addr & ~0x3; word_t val; get_word_val(mem, align_addr, &val); set_memory(align_addr, val); align_addr+=4; get_word_val(mem, align_addr, &val); set_memory(align_addr, val); } else { set_memory(mem_addr, mem_data); } } #endif } } if (update_cc) cc = cc_in; }
/* Update the processor state */ static exc_t update_state() { exc_t status = EXC_NONE; if (plusmode) { prev_icode = prev_icode_in; prev_ifun = prev_ifun_in; prev_valc = prev_valc_in; prev_valm = prev_valm_in; prev_valp = prev_valp_in; prev_bcond = prev_bcond_in; } else { pc = pc_in; } cc = cc_in; /* Writeback */ if (destE != REG_NONE) set_reg_val(reg, destE, vale); if (destM != REG_NONE) set_reg_val(reg, destM, valm); if (mem_write) { if (!set_word_val(mem, mem_addr, mem_data)) { sim_log("Couldn't write to address 0x%x\n", mem_addr); status = EXC_ADDR; } else { sim_log("Wrote 0x%x to address 0x%x\n", mem_data, mem_addr); #ifdef HAS_GUI if (gui_mode) { if (mem_addr % 4 != 0) { /* Just did a misaligned write. Need to display both words */ word_t align_addr = mem_addr & ~0x3; word_t val; get_word_val(mem, align_addr, &val); set_memory(align_addr, val); align_addr+=4; get_word_val(mem, align_addr, &val); set_memory(align_addr, val); } else { set_memory(mem_addr, mem_data); } } #endif// HAS_GUI } } return status; }
/* Please see header for specification */ Anvil::Buffer::Buffer(Anvil::Device* device_ptr, VkDeviceSize size, Anvil::QueueFamilyBits queue_families, VkSharingMode queue_sharing_mode, VkBufferUsageFlags usage_flags, bool should_be_mappable, bool should_be_coherent, const void* opt_client_data) :m_buffer (VK_NULL_HANDLE), m_buffer_size (size), m_device_ptr (device_ptr), m_memory_block_ptr (nullptr), m_parent_buffer_ptr(0), m_start_offset (0), m_usage_flags (static_cast<VkBufferUsageFlagBits>(usage_flags) ) { /* Sanity checks */ if (!should_be_mappable) { anvil_assert(!should_be_coherent); /* For host->gpu writes to work in this case, we will need the buffer to work as a target * for buffer->buffer copy operations. */ m_usage_flags = static_cast<VkBufferUsageFlagBits>(m_usage_flags | VK_BUFFER_USAGE_TRANSFER_DST_BIT); } /* Create the buffer object */ create_buffer(queue_families, queue_sharing_mode, size); /* Create a memory object and preallocate as much space as we need */ { Anvil::MemoryBlock* memory_block_ptr = nullptr; memory_block_ptr = new Anvil::MemoryBlock(m_device_ptr, m_buffer_memory_reqs.memoryTypeBits, m_buffer_memory_reqs.size, should_be_mappable, should_be_coherent); anvil_assert(memory_block_ptr != nullptr); set_memory(memory_block_ptr); if (opt_client_data != nullptr) { write(0, size, opt_client_data); } memory_block_ptr->release(); } /* Register the object */ Anvil::ObjectTracker::get()->register_object(Anvil::ObjectTracker::OBJECT_TYPE_BUFFER, this); }
MultilinConfiguration(SolverConfiguration & solve_options, std::shared_ptr<SystemRandomizer> _random) { init(); set_memory(solve_options); set_randomizer(_random); }
MultilinConfiguration(SolverConfiguration & solve_options, const WitnessSet & W) { init(); set_memory(solve_options); make_randomizer(solve_options, W); }
/* Update the processor state */ static void update_state() { if (plusmode) { prev_icode = prev_icode_in; prev_ifun = prev_ifun_in; prev_valc = prev_valc_in; prev_valm = prev_valm_in; prev_valp = prev_valp_in; prev_bcond = prev_bcond_in; } else { pc = pc_in; } cc = cc_in; /* Writeback */ if (destE != REG_NONE) set_reg_val(reg, destE, vale); if (destM != REG_NONE) set_reg_val(reg, destM, valm); if (mem_write) { /* Should have already tested this address */ set_word_val(mem, mem_addr, mem_data); sim_log("Wrote 0x%x to address 0x%x\n", mem_data, mem_addr); #ifdef HAS_GUI if (gui_mode) { if (mem_addr % 4 != 0) { /* Just did a misaligned write. Need to display both words */ word_t align_addr = mem_addr & ~0x3; word_t val; get_word_val(mem, align_addr, &val); set_memory(align_addr, val); align_addr+=4; get_word_val(mem, align_addr, &val); set_memory(align_addr, val); } else { set_memory(mem_addr, mem_data); } } #endif /* HAS_GUI */ } }
/* Reduces the cycles_away of all changes by one and executes any changes that have a cycles_away of 0 */ Change* execute_changes(Change* changes, Change** last_change_ptr, Instruction** code_ptr) { Change* first_change = changes; Change* prev_change = NULL; /* Iterate through all changes */ while(changes) { changes->cycles_away -= 1; if (changes->cycles_away == 0) { /* Perform effect */ switch(changes->type) { case REGISTER: set_register(changes->location,changes->value); break; case MEMORY: set_memory(changes->location,changes->value); break; case BRANCH: *code_ptr = changes->target; break; case DISPLAY: fprintf(stdout,"%d\n",changes->value); break; } /* Delete change record */ if (prev_change) { prev_change->next = changes->next; free(changes); changes = prev_change->next; } else { first_change = changes->next; free(changes); changes = first_change; } } else { prev_change = changes; changes = changes->next; } } *last_change_ptr = prev_change; return (first_change); }
void VFrame::set_memory(BC_Bitmap *bitmap) { int shmid = 0; unsigned char *data = 0; if( bitmap->is_shared() ) shmid = bitmap->get_shmid(); else data = bitmap->get_data(); set_memory(data, shmid, bitmap->get_y_offset(), bitmap->get_u_offset(), bitmap->get_v_offset()); }
int main(int argc, char *argv[]) { int i; if(argc==1) { printf("Argument required. To use default memory, enter '0', to set\n your own memory, enter any other argument\n"); return 0; } //if no argument is given in the command line, program prints error //message and terminates if(strcmp(argv[1],"0") == 0) set_memory(); //if argument given is 0, program calls set_memory() to run using //default memory settings else if(strcmp(argv[1],"0") != 0) read_memory(); //if some nonzero argument is entered, program calls read_memory, //prompting the user to enter starting memory values //byte-by-byte while(pc<MEM_SIZE) { strcpy(ir, memory[pc]); pc++; execute(); //loads memory next piece of memory into the IR, increments the PC, and //executes the command found in the designated memory space. if(halt) break; //if the command executed in memory is the "halt" command, program stops //going through memory. } printf("Memory:\n"); print_memory(); printf("Accumulator:\n"); printf("%s\n",ac); //prints values in accumulator and memory return 0; }
void* get_memptr(const char* filename, size_t size, int* id_to_save) { CHECK(filename, "Argumented filename pointer is NULL"); CHECK(id_to_save,"Argumented pointer is NULL" ); WARN(size >= PAGESIZE, "Requested size of shared memory will be rounded up to PAGESIZE"); int cond = creat(filename, 0660); if (cond == -1) printf("Failed to create file [%s]\n", filename); CHECK(cond != -1 || (cond == -1 && errno == EEXIST), "Unexpected error during sharing memory file creation"); int shared_id = set_memory(filename, size); CHECK(shared_id != -1, "Failed to get shared memory"); void* shm_ptr = shmat(shared_id, NULL, 0); CHECK(shm_ptr != (void*) -1, "Failed to get pointer from share memory id"); memset(shm_ptr, size, 0); *id_to_save = shared_id; return shm_ptr; }
int emu_pushf(unsigned char *lina) { Bit32u val; trace("pushf\n"); ASSERT(!opa.pe); if (opa.opb==4) { val = REG(eflags); } else { val = LWORD(eflags); } LWORD(esp) -= opa.opb; val &= ~(VM_MASK | RF_MASK); if (set_memory(LWORD(ss), LWORD(esp), val, opa.opb)) return -1; REG(eip) ++; return 0; }
int main(int argc, char* argv[]) { int mem_size = 0; int reg_size = 0; int current_argument = 1; int machine_initialized = 0; Instruction* code; /* Set default stall mode - branches, registers, and memory */ set_stall_mode(3 /*2*/); while(current_argument < argc) { if (strcmp(argv[current_argument],"-h") == 0) { print_help(); return 0; } /* All of the following flags require at least one additional parameter, so perform check here. */ if (current_argument == argc - 1) { fprintf(stderr,"Invalid flag sequence: make sure any required numbers are included.\n"); return(1); } if (strcmp(argv[current_argument],"-r") == 0) { reg_size = (int) strtol(argv[current_argument+1],(char**)NULL,10); current_argument += 2; } else { if (strcmp(argv[current_argument],"-m") == 0) { mem_size = (int) strtol(argv[current_argument+1],(char**)NULL,10); current_argument += 2; } else { if (strcmp(argv[current_argument],"-s") == 0) { set_stall_mode((int)strtol(argv[current_argument+1],(char**)NULL,10)); current_argument += 2; } else { if (strcmp(argv[current_argument],"-i") == 0) { int i; int start_location = (int)strtol(argv[current_argument+1],(char**)NULL,10); initialize_machine(reg_size,mem_size); machine_initialized = 1; for(i = 0; i < (argc - current_argument - 2); i++) set_word(start_location + 4*i, (int)strtol(argv[current_argument+2+i], (char**)NULL,10)); current_argument = argc; } else { if (strcmp(argv[current_argument],"-c") == 0) { int i; int start_location = (int)strtol(argv[current_argument+1], (char**)NULL,10); initialize_machine(reg_size,mem_size); machine_initialized = 1; for(i = 0; i < (argc - current_argument - 2); i++) set_memory(start_location + i, (char)strtol(argv[current_argument+2+i], (char**)NULL,10)); current_argument = argc; } else { fprintf(stderr,"Invalid flag specified\n"); return 0; } } } } } } if (!machine_initialized) initialize_machine(reg_size,mem_size); code = parse(); if (!code) { fprintf(stderr,"Error reading input file, simulator not run.\n"); return 1; } simulate(code); return 0; };
void set_memory(Node* c, Node* adr) { set_memory(c,_gvn.type(adr)->is_ptr()); }
void set_memory(Node* c, const TypePtr *tp) { set_memory(c,C->get_alias_index(tp)); }
MultilinConfiguration(SolverConfiguration & solve_options) { init(); set_memory(solve_options); }