int main(int argc, char **argv) { int optidx = 0; setprogname(argv[0]); if(getarg(args, num_args, argc, argv, &optidx)) usage(1); if(help_flag) usage(0); if(version_flag) { print_version(NULL); exit(0); } if(argc == optidx) usage(1); filename = argv[optidx]; yyin = fopen(filename, "r"); if(yyin == NULL) err(1, "%s", filename); yyparse(); generate_commands(); if(numerror) return 1; return 0; }
static void read_frame_fde(U8_T IP, U8_T fde_pos) { int fde_dwarf64 = 0; U8_T fde_length = 0; U8_T fde_end = 0; U8_T ref_pos = 0; U8_T cie_ref = 0; int fde_flag = 0; dio_EnterSection(NULL, rules.section, fde_pos); fde_length = dio_ReadU4(); assert(fde_length > 0); if (fde_length == ~(U4_T)0) { fde_length = dio_ReadU8(); fde_dwarf64 = 1; } ref_pos = dio_GetPos(); fde_end = ref_pos + fde_length; cie_ref = fde_dwarf64 ? dio_ReadU8() : dio_ReadU4(); if (rules.eh_frame) fde_flag = cie_ref != 0; else if (fde_dwarf64) fde_flag = cie_ref != ~(U8_T)0; else fde_flag = cie_ref != ~(U4_T)0; assert(fde_flag); if (fde_flag) { U8_T Addr, Range; if (rules.eh_frame) cie_ref = ref_pos - cie_ref; if (cie_ref != rules.cie_pos) read_frame_cie(fde_pos, cie_ref); Addr = read_frame_data_pointer(rules.addr_encoding, &rules.loc_section, 0); Range = read_frame_data_pointer(rules.addr_encoding, NULL, 0); assert(Addr <= IP && Addr + Range > IP); if (Addr <= IP && Addr + Range > IP) { U8_T location0 = Addr; if (rules.cie_aug != NULL && rules.cie_aug[0] == 'z') { rules.fde_aug_length = dio_ReadULEB128(); rules.fde_aug_data = dio_GetDataPtr(); dio_Skip(rules.fde_aug_length); } copy_register_rules(&frame_regs, &cie_regs); rules.location = Addr; regs_stack_pos = 0; for (;;) { if (dio_GetPos() >= fde_end) { rules.location = Addr + Range; break; } exec_stack_frame_instruction(Addr); assert(location0 <= IP); if (rules.location > IP) break; location0 = rules.location; } dwarf_stack_trace_addr = location0; dwarf_stack_trace_size = rules.location - location0; if (rules.reg_id_scope.machine == EM_ARM && IP + 4 == Addr + Range) { /* GCC generates invalid frame info for ARM function epilogue */ /* Ignore frame info, fall-back to stack crawl logic */ dio_ExitSection(); return; } generate_commands(); if (dwarf_stack_trace_regs_cnt == 0) { /* GHS generates dummy frame info with all registers marked undefined */ /* Ignore frame info, fall-back to stack crawl logic */ dwarf_stack_trace_fp->cmds_cnt = 0; dwarf_stack_trace_addr = 0; dwarf_stack_trace_size = 0; dio_ExitSection(); return; } } } dio_ExitSection(); }
static void generate_plt_section_commands(Context * ctx, ELF_File * file, U8_T offs) { RegisterRules * reg = NULL; memset(&rules, 0, sizeof(StackFrameRules)); rules.ctx = ctx; rules.reg_id_scope.big_endian = file->big_endian; rules.reg_id_scope.machine = file->machine; rules.reg_id_scope.os_abi = file->os_abi; rules.reg_id_scope.elf64 = file->elf64; rules.reg_id_scope.id_type = REGNUM_DWARF; rules.address_size = file->elf64 ? 8 : 4; clear_frame_registers(&cie_regs); clear_frame_registers(&frame_regs); switch (rules.reg_id_scope.machine) { case EM_386: frame_regs.cfa_rule = RULE_OFFSET; frame_regs.cfa_register = 4; /* esp */ if (offs == 0) { frame_regs.cfa_offset = 8; } else if (offs < 16) { frame_regs.cfa_offset = 12; } else if ((offs - 16) % 16 < 11) { frame_regs.cfa_offset = 4; } else { frame_regs.cfa_offset = 8; } rules.return_address_register = 8; /* eip */ reg = get_reg(&frame_regs, rules.return_address_register); reg->rule = RULE_OFFSET; reg->offset = -4; generate_commands(); break; case EM_X86_64: frame_regs.cfa_rule = RULE_OFFSET; frame_regs.cfa_register = 7; /* rsp */ if (offs == 0) { frame_regs.cfa_offset = 16; } else if (offs < 16) { frame_regs.cfa_offset = 24; } else if ((offs - 16) % 16 < 11) { frame_regs.cfa_offset = 8; } else { frame_regs.cfa_offset = 16; } rules.return_address_register = 16; /* rip */ reg = get_reg(&frame_regs, rules.return_address_register); reg->rule = RULE_OFFSET; reg->offset = -8; generate_commands(); break; case EM_PPC: rules.return_address_register = 108; /* LR */ frame_regs.cfa_rule = RULE_OFFSET; frame_regs.cfa_register = 1; /* R1 */ generate_commands(); break; case EM_PPC64: rules.return_address_register = 65; /* LR */ frame_regs.cfa_rule = RULE_OFFSET; frame_regs.cfa_register = 1; /* R1 */ generate_commands(); break; case EM_ARM: rules.return_address_register = 14; /* LR */ frame_regs.cfa_rule = RULE_OFFSET; frame_regs.cfa_register = 13; /* SP */ generate_commands(); break; case EM_MICROBLAZE: rules.return_address_register = 15; /* R15 */ frame_regs.cfa_rule = RULE_OFFSET; frame_regs.cfa_register = 1; /* R1 */ generate_commands(); break; case EM_AARCH64: rules.return_address_register = 30; /* LR */ frame_regs.cfa_rule = RULE_OFFSET; frame_regs.cfa_register = 31; /* SP */ generate_commands(); break; } }
void track_server_code (){ RegisterAs("TRACKSERVER"); // Server data sw_info sw_infos [NUM_SWITCHES]; int sensor_info [NUM_SENSORS]; // time when the sensor is hit int broken_sensors[NUM_SENSORS] = {0}; // Server's track data track_node track[TRACK_MAX]; init_track(track); init_broken_sensors(broken_sensors); track_node *src, *dst; // Received stuff track_receive rcv_buff; int sender_tid; int request_type; int sensor_index = 0; //Reply buffs int reply_dist = 0; int reply_index = 0; struct track_loc reply_loc; char reply_buff; int reply_buff_loc_dist [2]; struct train_server_request tsr; int train_server_id; while((train_server_id = WhoIs("TRAINSERVER")) == -1); int track_to_train_courier_tid = Create(PR_COURIER, track_to_train_courier_code); int track_to_train_courier_ready = 0; Queue train_serverQ; struct train_server_request allocated_buff[TRACK_TO_TRAIN_QUEUE_SIZE]; Queue_init (&train_serverQ, allocated_buff, TRACK_TO_TRAIN_QUEUE_SIZE, sizeof(struct train_server_request)); //things for shortest path request track_node* path[TRACK_MAX] = {0}; int dist[TRACK_MAX] = {0}; int shortest_dist = 0; routing_command commands[TRACK_MAX]; init_routing_commands(commands); // switch_command sw_commands[NUM_MAX_SWITCH_ROUTE_COMMANDS]; // memset(sw_commands, 0, NUM_MAX_SWITCH_ROUTE_COMMANDS * sizeof(switch_command)); //things for changing switches when train goes //within a specified route Queue switch_queues[NUM_TRAINS]; Queue *Q; switch_command switch_queue_buffers[NUM_TRAINS][NUM_MAX_SWITCH_ROUTE_COMMANDS]; memset(switch_queue_buffers, 0, NUM_TRAINS * NUM_MAX_SWITCH_ROUTE_COMMANDS * sizeof(switch_command)); int trnum; for (trnum = 0; trnum < NUM_TRAINS; trnum++) { Queue_init(&switch_queues[trnum], switch_queue_buffers[trnum], NUM_MAX_SWITCH_ROUTE_COMMANDS, sizeof(switch_command)); } // //Reservation data structures track_reservation track_reservations[TRACK_MAX]; train_reservation_info tr_reservation_infos[NUM_TRAINS]; memset(track_reservations, 0, TRACK_MAX * sizeof(track_reservation)); memset(tr_reservation_infos, -1, NUM_TRAINS * sizeof(train_reservation_info)); // Queue isReservableQueue; isReservableQueueItem isReservableQueueItems[NUM_TRAINS]; Queue_init(&isReservableQueue, isReservableQueueItems, NUM_TRAINS, sizeof(isReservableQueueItem)); isReservableQueueItem irqi; int reserve_ret = -1; int ret; while(1){ Receive(&sender_tid, &rcv_buff, sizeof(track_receive)); request_type = rcv_buff.type; switch (request_type){ case TRACK_TYPE_COURIER_RTS: track_to_train_courier_ready = 1; break; case TRACK_TYPE_SENSOR_INFO: sensor_index = (rcv_buff.data.track_data.data2 - 'A')*16+rcv_buff.data.track_data.data1-1; //if (sensor_index == 56) {HardDebug("D9 is hit. Hit time:%d. Rcv Time:%d", rcv_buff.data.track_data.time, Time());} sensor_info[sensor_index] = rcv_buff.data.track_data.time; Reply(sender_tid, &reply_buff, sizeof(char)); tsr.type = TRAIN_TYPE_SENSOR_UPDATE; memcpy(&tsr.data, &rcv_buff.data.track_data, sizeof(track_info)); if (!broken_sensors[sensor_index]) { //Send(train_server_id, &tsr, sizeof(struct train_server_request), &reply_buff, sizeof(char)); ret = Queue_push(&train_serverQ, &tsr); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); } break; case TRACK_TYPE_SWITCH_INFO: (sw_infos[(int)rcv_buff.data.track_data.data1]).swdir = rcv_buff.data.track_data.data2; (sw_infos[(int)rcv_buff.data.track_data.data1]).time = rcv_buff.data.track_data.time; Reply(sender_tid, &reply_buff, sizeof(char)); tsr.type = TRAIN_TYPE_SWITCH_UPDATE; memcpy(&tsr.data, &rcv_buff.data.track_data, sizeof(track_info)); //Send(train_server_id, &tsr, sizeof(struct train_server_request), &reply_buff, sizeof(char)); ret = Queue_push(&train_serverQ, &tsr); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); break; case TRACK_TYPE_DIST: if((int)rcv_buff.data.track_data.data1 >= TRACK_MAX || (int)rcv_buff.data.track_data.data2 >= TRACK_MAX) { reply_dist = 0; } else { src = &track[(int)rcv_buff.data.track_data.data1]; dst = &track[(int)rcv_buff.data.track_data.data2]; reply_dist = get_dist_between_nodes(src, dst, sw_infos); } Reply(sender_tid, &reply_dist, sizeof(int)); break; case TRACK_TYPE_NEXT_LOC: //get current loc_index and find next node __get_next_node((int)rcv_buff.data.track_data.data1, track, sw_infos, &reply_loc.index, reply_loc.name); Reply(sender_tid, &reply_loc, sizeof(struct track_loc)); break; case TRACK_TYPE_NEXT_SENSOR: reply_index = get_next_sensor_index((int)rcv_buff.data.track_request_data.data1, track, sw_infos, broken_sensors, &tsr.data.spd.spd_val); Assert(reply_index == tsr.data.spd.spd_val.next_expected_sensor_index, "reply_index != result->next_expected_sensor_index"); //Debug("TRACKSERVER: Got next expected sensor %d, after that %d", tsr.data.spd.spd_val.next_expected_sensor_index, tsr.data.spd.spd_val.sensor_after_expected_sensor); Reply(sender_tid, &reply_index, sizeof(int)); tsr.type = TRAIN_TYPE_SENSOR_PREDICTION; tsr.data.spd.trnum = (int)rcv_buff.data.track_request_data.data2; if (rcv_buff.data.track_request_data.data3) { //Send(train_server_id, &tsr, sizeof(train_server_request), &reply_buff, sizeof(char)); ret = Queue_push(&train_serverQ, &tsr); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); } break; case TRACK_TYPE_LOC_NAME: Reply(sender_tid, (char*)track[(int)rcv_buff.data.track_data.data1].name, 6 * sizeof(char)); break; case TRACK_TYPE_SENSOR_REVERSE: reply_index = get_reverse_sensor((int)rcv_buff.data.track_request_data.data1, track, sw_infos, broken_sensors, &tsr.data.spd.spd_val); Reply(sender_tid, &reply_index, sizeof(int)); tsr.data.spd.trnum = (int)rcv_buff.data.track_request_data.data2; if (rcv_buff.data.track_request_data.data3) { //Send(train_server_id, &tsr, sizeof(train_server_request), &reply_buff, sizeof(char)); ret = Queue_push(&train_serverQ, &tsr); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); } break; case TRACK_TYPE_UPDATE_LOC_AND_DISTANCE: translate_sensor_loc(rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2, track, sw_infos, reply_buff_loc_dist); Reply(sender_tid, reply_buff_loc_dist, 2*sizeof(int)); break; case TRACK_TYPE_FIND_ROUTE: Warning(((0 <= rcv_buff.data.track_request_data.data2 && rcv_buff.data.track_request_data.data2 < TRACK_MAX) && (0 <= rcv_buff.data.track_request_data.data3 && rcv_buff.data.track_request_data.data3 < TRACK_MAX)), "TRACKSERVER: TRACK_TYPE_FIND_ROUTE - Source(%d) or destination(%d) is invalid", rcv_buff.data.track_request_data.data2, rcv_buff.data.track_request_data.data3); //Debug("FINDING ROUTE:trnum:%d ~ src:%s ~ dest:%s ~ offset:%d",rcv_buff.data.track_request_data.data1, track[rcv_buff.data.track_request_data.data2].name, track[rcv_buff.data.track_request_data.data3].name, rcv_buff.data.track_request_data.data4); shortest_dist = shortest_path((int)rcv_buff.data.track_request_data.data2, (int)rcv_buff.data.track_request_data.data3, track, path, dist, track_reservations); if (shortest_dist == __INFINITY) { shortest_path((int)rcv_buff.data.track_request_data.data2, (int)rcv_buff.data.track_request_data.data3, track, path, dist, 0); } generate_commands(path, track, commands); print_commands(commands); pull_out_switch_orders(commands, tsr.data.path_commands.sw_commands, &switch_queues[rcv_buff.data.track_request_data.data1]); pull_out_reverse_orders(commands, tsr.data.path_commands.rv_commands); tsr.type = TRAIN_TYPE_ROUTE_SWITCH_ORDERS; Reply(sender_tid, &tsr, sizeof(train_server_request)); break; case TRACK_TYPE_RESERVATION_INIT: reserve_ret = reserve_inital_piece (track_reservations, track, tr_reservation_infos, sw_infos, &switch_queues[rcv_buff.data.track_request_data.data1], rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2, rcv_buff.data.track_request_data.data3, rcv_buff.data.track_request_data.data4); Debug("TRACKSERVER: Received reservation initialization request for train %d", rcv_buff.data.track_request_data.data1); tsr.type = TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); break; case TRACK_TYPE_RESERVATION: Q = &switch_queues[rcv_buff.data.track_request_data.data1]; reserve_ret = reserve_track(track_reservations, track, tr_reservation_infos, sw_infos, Q, rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2); ret = release_track(track_reservations, track, tr_reservation_infos, sw_infos, rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data3); Assert (ret != -1, "TRACKSERVER: release failed: ret:%d", ret); tsr.type = (reserve_ret == -1) ? TRAIN_TYPE_RESERVATION_FAILURE : TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); if (/*rcv_buff.data.track_request_data.data2 < 0 ||*/ rcv_buff.data.track_request_data.data3 > 0) { check_isReservableRequests(&isReservableQueue, &train_serverQ, track, sw_infos, track_reservations, tr_reservation_infos, train_server_id); } print_total_reserved_dist(track_reservations, tr_reservation_infos, rcv_buff.data.track_request_data.data1); break; case TRACK_TYPE_RESERVATION_REVERSE: reserve_ret = reverse_reservation (track, tr_reservation_infos, sw_infos, rcv_buff.data.track_request_data.data1); tsr.type = TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); break; case TRACK_TYPE_RESERVATION_SENSOR_UPDATE: reserve_ret = reservation_sensor_update(track_reservations, track, tr_reservation_infos, sw_infos, &switch_queues[rcv_buff.data.track_request_data.data1], rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2, rcv_buff.data.track_request_data.data3, rcv_buff.data.track_request_data.data4, rcv_buff.data.track_request_data.data5); tsr.type = (reserve_ret == -1) ? TRAIN_TYPE_RESERVATION_FAILURE : TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); //check_isReservableRequests(&isReservableQueue, &train_serverQ, track, sw_infos, track_reservations, tr_reservation_infos, train_server_id); break; case TRACK_TYPE_RESERVATION_STOP_UPDATE: reserve_ret = reservation_stop_update ( track_reservations, track, tr_reservation_infos, sw_infos, &switch_queues[rcv_buff.data.track_request_data.data1], rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2, rcv_buff.data.track_request_data.data3, rcv_buff.data.track_request_data.data4, rcv_buff.data.track_request_data.data5); tsr.type = /*(reserve_ret == -1) ? TRAIN_TYPE_RESERVATION_FAILURE :*/ TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); break; case TRACK_TYPE_IS_RESERVABLE: tsr.type = TRAIN_TYPE_REQ_IN_PROGRESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); irqi.trnum = rcv_buff.data.track_request_data.data1; irqi.mm = rcv_buff.data.track_request_data.data2; ret = Queue_push(&isReservableQueue, &irqi); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); break; case TRACK_TYPE_PRINT_RESERVATIONS: Reply(sender_tid, &reply_buff, sizeof(char)); print_reservations(track_reservations, track, tr_reservation_infos); break; default: Reply(sender_tid, &reply_buff, sizeof(char)); Warning(0,"Unknown receive in track_server_code: type=%d from %d", request_type, sender_tid); break; } if (track_to_train_courier_ready && !Queue_pop(&train_serverQ, &tsr)){ Reply(track_to_train_courier_tid, &tsr, sizeof(train_server_request)); track_to_train_courier_ready = 0; } } Exit(); Warning(0,"Unexpected return from Exit() at track_server_code\n\r"); }