int get_twos_complement(string s) {
int num = 0;
if (s[0] == '0') {
return get_int_from_string(s);
}
else {
// if 2'complement of a negative no y is x then ~x + 1 = -y
for(int i = 0; i < s.size(); ++i) {
s[i] = '0' + (1 - (s[i] - '0'));
}
num = get_int_from_string(s);
num++;
return (-num);
}
}
static void setDummyTarget(void) {
int x, y;
char buf[50];
consume_uart_arg("x", buf, 50);
if (!get_int_from_string(buf, &x)) {
xil_printf("Not a valid integer: %s\r\n", buf);
return;
}
consume_uart_arg("y", buf, 50);
if (!get_int_from_string(buf, &y)) {
xil_printf("Not a valid integer: %s\r\n", buf);
return;
}
generate_debug_target(x,y);
}
static void SetObjId(void) {
char buf[50];
int result;
consume_uart_arg("obj id [0-255]", buf, 50);
if (get_int_from_string(buf, &result)) {
SetObjIdValue(result);
} else {
xil_printf("Not a valid integer: %s\r\n", buf);
}
}
static void SetRedThreshold(void) {
char buf[50];
int result;
consume_uart_arg("thresh", buf, 50);
if (get_int_from_string(buf, &result)) {
SetRedThresholdValue(result);
} else {
xil_printf("Not a valid integer: %s\r\n", buf);
}
}
static void SetSizeThreshold(void) {
char buf[50];
int result;
consume_uart_arg("size threshold:", buf, 50);
if (get_int_from_string(buf, &result)) {
setMinObjSize(result);
} else {
xil_printf("Not a valid integer: %s\r\n", buf);
}
}
void Simulator::decode(pipeline_instr& p){
string IR = p.IR;
p.opcode = get_int_from_string(IR.substr(0,3));
p.immediate = (get_int_from_string(IR.substr(3,1)) >= 1)?true:false;
if(p.opcode == 7 && p.immediate == 0)
p.opcode = 7;
if (p.opcode == 5){ // jump instruction
p.op1 = get_twos_complement(IR.substr(4,8));
}
else if (p.opcode == 6){ // BEQZ
p.op1 = get_int_from_string(IR.substr(4,4));
p.op2 = get_twos_complement(IR.substr(8,8));
}
else if (p.opcode <= 4) { // add, sub, mul, ld,st
p.op1 = get_int_from_string(IR.substr(4,4));
p.op2 = get_int_from_string(IR.substr(8,4));
if (p.immediate) {
p.op3 = get_twos_complement(IR.substr(12,4));
}
else {
p.op3 = get_int_from_string(IR.substr(12,4));
}
}
}
static void TestArgs(void) {
char buf[50];
int result;
consume_uart_arg("derp", buf, 50);
xil_printf("You typed out: %s\r\n", buf);
consume_uart_arg("num", buf, 50);
if (get_int_from_string(buf, &result)) {
xil_printf("Got number: %d\r\n", result);
} else {
xil_printf("Not a valid integer: %s\r\n", buf);
}
}
uint32 http_fill_body_data(HTTP_RESPONSE* response, const char* p_data, uint32 data_len)
{
uint32 ret = SUCCEEDED;
uint32 content_len = (uint32)-1;
uint32 left = 0;
char* body_pos = 0, *is_chunked = 0, *temp_content = 0;
uint32 number_len = 0, chunked_len = 0;
//ret = get_http_response_int_value_for_key(response->header.header, "Content-Length", &content_len);
//if (ret != SUCCEEDED)
content_len = response->header.content_len;
if (content_len == (uint32)-1 && response->header.chunked == 0)
{
return FAILED;
}
if(content_len != (uint32)-1)
{
if (response->content == 0)
{
response->content = malloc(content_len);
response->current_len = 0;
response->content_len = content_len;
response->chunk_remaind = content_len;
}
if (data_len <= response->chunk_remaind)
{
memcpy(response->content + response->current_len, p_data, data_len);
response->current_len += data_len;
response->chunk_remaind -= data_len;
}
else
{
memcpy(response->content + response->current_len, p_data, response->chunk_remaind);
response->current_len += response->chunk_remaind;
response->chunk_remaind -= response->chunk_remaind;
}
printf("on http_fill_body_data remaind:%d\r\n", response->chunk_remaind);
return response->chunk_remaind <= 0 ? 0: 1;
}
else
{
while(1)
{
if (response->chunk_remaind > 0)
{
if (check_and_ensure_enough_response(response, response->chunk_remaind) != SUCCEEDED)
return 0;
if (response->chunk_remaind > data_len)
{
memcpy(response->content + response->current_len, p_data, data_len);
response->current_len += data_len;
response->chunk_remaind -= data_len;
return 1;
}
memcpy(response->content + response->current_len, p_data, response->chunk_remaind);
response->current_len += response->chunk_remaind;
data_len -= response->chunk_remaind;
p_data += response->chunk_remaind;
response->chunk_remaind = 0;
if (data_len > 2)
{
data_len -= 2;
p_data += 2;
}
}
ret = get_int_from_string(p_data, data_len, &chunked_len, &number_len);
if (ret != SUCCEEDED) return 1;
printf("on http_fill_body_data next chunk length:%d\r\n", chunked_len);
data_len -= (number_len + 2); p_data += (number_len + 2);
if (chunked_len == 0)
{
printf("on http_fill_body_data find the last chunk: %s\r\nremain_data:%d\r\n", p_data, data_len);
if (p_data[0] == '\r' && p_data[1] == '\n')
{
printf("on http_fill_body_data all done...\r\n");
p_data += 2; data_len -= 2;
if (data_len > 0)
http_fill_foottag(response, p_data, data_len);
return 0;
}
else
return 1;
}
if (check_and_ensure_enough_response(response, chunked_len) != SUCCEEDED)
return 0;
if (chunked_len > data_len)
{
memcpy(response->content + response->current_len, p_data, data_len);
response->current_len += data_len;
response->chunk_remaind = chunked_len - data_len;
return 1;
}
else
{
memcpy(response->content + response->current_len, p_data, chunked_len);
response->chunk_remaind = 0;
response->current_len += chunked_len;
p_data += (chunked_len + 2); data_len -= (chunked_len + 2);
}
}
}
}
int Simulator::decode(int ins_index){
bool is_raw = false;
if (prev_raw_flag){
prev_raw_flag = false;
temp_fetch = ins_pipeline[ins_index];
ins_pipeline[ins_index].opcode = 7;
ins_pipeline[ins_index].IR = "1111000000000000";
}
if(prev_ins_decoded_is_branch){
prev_ins_decoded_is_branch = false;
ins_pipeline[ins_index].opcode = 7;
ins_pipeline[ins_index].IR = "1111000000000000";
if (!branch_pred_enabled) {
pc -= 2;
}
}
string IR = ins_pipeline[ins_index].IR;
ins_pipeline[ins_index].opcode = get_int_from_string(IR.substr(0,3));
ins_pipeline[ins_index].immediate = (get_int_from_string(IR.substr(3,1)) >= 1)?true:false;
out << ins_pipeline[ins_index].IR << endl;
if(ins_pipeline[ins_index].opcode == 7 && ins_pipeline[ins_index].immediate == 0)
ins_pipeline[ins_index].opcode = 8;
if (ins_pipeline[ins_index].opcode == 5){ // jump instruction
ins_pipeline[ins_index].op1 = get_twos_complement(IR.substr(4,8));
prev_ins_decoded_is_branch = true;
control_flag = true;
if (branch_pred_enabled) {
control_flag = false;
if (bp.count(ins_pipeline[ins_index].pc) == 0) {
bp[ins_pipeline[ins_index].pc] = BranchPredictor();
btb[ins_pipeline[ins_index].pc] = ins_pipeline[ins_index].pc + 2;
}
if (bp[ins_pipeline[ins_index].pc].predict()) {
pc = btb[ins_pipeline[ins_index].pc];
}
else {
prev_ins_decoded_is_branch = false;
}
}
}
else if (ins_pipeline[ins_index].opcode == 6){ // BEQZ
ins_pipeline[ins_index].op1 = get_int_from_string(IR.substr(4,4));
ins_pipeline[ins_index].op2 = get_twos_complement(IR.substr(8,8));
prev_ins_decoded_is_branch = true;
control_flag = true;
if (branch_pred_enabled) {
control_flag = false;
if (bp.count(ins_pipeline[ins_index].pc) == 0) {
bp[ins_pipeline[ins_index].pc] = BranchPredictor();
btb[ins_pipeline[ins_index].pc] = ins_pipeline[ins_index].pc + 2;
}
if (bp[ins_pipeline[ins_index].pc].predict()) {
pc = btb[ins_pipeline[ins_index].pc];
}
else {
prev_ins_decoded_is_branch = false;
}
}
if (register_status[ins_pipeline[ins_index].op1] != -1){
is_raw = true;
wait_on_reg[ins_pipeline[ins_index].op1] = true;
ins_pipeline[ins_index].wait_for_op1 = true;
}
}
else if (ins_pipeline[ins_index].opcode <= 4) { // add, sub, mul, ld,st
ins_pipeline[ins_index].op1 = get_int_from_string(IR.substr(4,4));
ins_pipeline[ins_index].op2 = get_int_from_string(IR.substr(8,4));
if (ins_pipeline[ins_index].immediate) {
ins_pipeline[ins_index].op3 = get_twos_complement(IR.substr(12,4));
}
else {
ins_pipeline[ins_index].op3 = get_int_from_string(IR.substr(12,4));
}
if( (ins_pipeline[ins_index].opcode <= 2 && ins_pipeline[ins_index].immediate) || ins_pipeline[ins_index].opcode == 3 )
if (register_status[ins_pipeline[ins_index].op2] != -1){
is_raw = true;
ins_pipeline[ins_index].wait_for_op2 = true;
wait_on_reg[ins_pipeline[ins_index].op2] = true;
}
if( (ins_pipeline[ins_index].opcode <=2 && !ins_pipeline[ins_index].immediate) ){
if (register_status[ins_pipeline[ins_index].op2] != -1){
wait_on_reg[ins_pipeline[ins_index].op2] = true;
is_raw = true;
ins_pipeline[ins_index].wait_for_op2 = true;
}
if (register_status[ins_pipeline[ins_index].op3] != -1){
wait_on_reg[ins_pipeline[ins_index].op3] = true;
is_raw = true;
ins_pipeline[ins_index].wait_for_op3 = true;
}
}
if(ins_pipeline[ins_index].opcode == 4) {
if (register_status[ins_pipeline[ins_index].op1] != -1){
wait_on_reg[ins_pipeline[ins_index].op1] = true;
is_raw = true;
ins_pipeline[ins_index].wait_for_op1 = true;
}
if (register_status[ins_pipeline[ins_index].op2] != -1){
wait_on_reg[ins_pipeline[ins_index].op2] = true;
is_raw = true;
ins_pipeline[ins_index].wait_for_op2 = true;
}
}
}
if (is_raw){
raw_flag = true;
prev_raw_flag = true;
temp_decode = ins_pipeline[ins_index];
ins_pipeline[ins_index].opcode = 7;
ins_pipeline[ins_index].IR = "1111000000000000";
}
else{
if(ins_pipeline[ins_index].opcode <= 3)
register_status[ins_pipeline[ins_index].op1] = ins_pipeline[ins_index].pc;
}
return 1;
}
