Example #1
0
static void copy_segment_to_m0(UM_machine machine, UM_segment_ID segment_ID)
{
        Seq_T mapped_segments = machine->address_space->mapped_segments;
        UM_segment temp = Seq_get(mapped_segments, segment_ID);
        int temp_length = UArray_length(temp->words);

        UM_segment duplicate = get_new_segment_of_size(temp_length);

        /* copy words into the new segment */
        for(int i=0; i<temp_length; i++){
                UM_word *word_i_p = UArray_at(temp->words, i);
                UM_word *duplicate_word_i_p = UArray_at(duplicate->words, i);
                *duplicate_word_i_p = *word_i_p;
        }

        duplicate->ID = 0;

        /* free the old program segment */
        UM_segment program = Seq_get(mapped_segments, 0);
        free_segment_memory(&program);

        /* put the duplicate segment in the place of the old program segment */
        Seq_put(mapped_segments, 0, duplicate);

        /* update num_instructions */
        machine->num_instructions = temp_length;
}
Example #2
0
void verifyMapped(Seq_T memorySegments, Seq_T unmappedSegments) {
    // Verifies that the available unmapped segments is updated upon mapping
    for(int i = 0; i < Seq_length(unmappedSegments); i++){
        UM_Word index = *(UM_Word*)Seq_get(unmappedSegments, i);
        if((UArray_T)Seq_get(memorySegments, index) != NULL){
            fprintf(stderr, 
                    "Unmapped segments not updated correctly for: %u\n", 
                    index);
            exit(1);
        }
    }

    for(int i = 0; i < MEM_SEG_LEN; i++) {
        UArray_T segments = (UArray_T)Seq_get(memorySegments, i);
        if (segments != NULL) {
            for(int j = 0; j < UArray_length(segments); j++) {
                // Each 32-bit word must be initialized to 0
                printf("memseg: %u\n", *(UM_Word*)UArray_at(segments, j));
                if(*(UM_Word*)UArray_at(segments, j) != 0) {
                    fprintf(stderr, "segment incorrectly initialized\n");
                    exit(1);
                }
            }
        }
    }
    printf("Verified bitch.\n");
}
Example #3
0
void test_add(Seq_T segments)
{

        Segment s;
        NEW (s);
        s->length = SEG_LENGTH;
        s->data = Seq_new(SEG_LENGTH);

        for (unsigned i = 0; i < s->length; i++) {
                uint32_t *word = malloc(sizeof(uint32_t)); 
                *word = i;
                Seq_addhi(s->data, word);
        }

        add_seg(SEG_LENGTH, s);

        Segment test = Seq_get(segments, SEG_LENGTH);

        for (unsigned i = 0; i < test->length; i++) {

                uint32_t *word = Seq_get(test->data, i);
                if (*word != i)
                        printf("ADD IS A FAIL!!!!!\n");
        }

        printf("ADD IS A SUCCESS!!!\n");


}
Example #4
0
File: unitTests.c Project: rlew/um
void verifyMapped(Seq_T memorySegments, Seq_T unmappedSegments) {
    assert(Seq_length(memorySegments) == Seq_length(unmappedSegments));
    for(int i = 0; i < Seq_length(memorySegments); i++){
        if(Seq_get(memorySegments, i) == Seq_get(unmappedSegments, i)){
            fprintf(stderr, "Cannot be both mapped and unmapped: %d\n", i);
         /*   if(Seq_get(unmappedSegments, i) == NULL) {
                fprintf(stderr, "Both NULL\n");
            }*/
            exit(1);
        }
        if(Seq_get(memorySegments, i) != NULL) {
            if(Seq_get(unmappedSegments, i) != NULL){
                fprintf(stderr, "Failed to unmap index: %d\n", i);
                exit(1);
            }
            UArray_T temp = Seq_get(memorySegments, i);
            for(UM_Word j = 0; j < (UM_Word)UArray_length(temp); j++) {
                UM_Word value = *(UM_Word*)UArray_at(temp, j); 
                if(value != 0){
                    printf("Segmented load at %d with value of %u\n", i, value);
                }
            }
        }
    }
    printf("Verified\n");
}
Example #5
0
/* Moves the segment identified by source to the target segment. The source
 * segment is duplicated and replaces the segment at the target ID.  
 */
void Segment_move(T seg_memory, ID_SIZE source, ID_SIZE target)
{
        WORD_SIZE *src = Seq_get(seg_memory->segments, source);
        WORD_SIZE size = src[0];
        Segment_unmap(seg_memory, target);
        assert (Segment_map(seg_memory, size) == target);
        WORD_SIZE *tar = Seq_get(seg_memory->segments, target);
        memcpy(tar, src, ((size + 1) * sizeof(WORD_SIZE)));
}
Example #6
0
/* 
 * Input:  Mem_T structure, unsigned segment index, unsigned offset
 * Output: Returns a uint32_t
 * Purpose: Retrieves a word from memory from at specified index and offset.
 */  
uint32_t load_word(Mem_T memory, unsigned segIndex, unsigned offset)
{
        Seq_T segment = (Seq_T)Seq_get(memory->segment_seq, segIndex);

        assert(segment != NULL);

        uint32_t word = (uint32_t)(uintptr_t)Seq_get(segment, offset);
        return word;
}
Example #7
0
/*
 * Initializes the program counter and returns the number of instructions.
 */
void mapProgram(FILE* program) {
    Seq_T words = Seq_new(PROGRAM_HINT);

    int c = getc(program);
    while(c != EOF) {
        UM_Word temp = 0;
        temp = Bitpack_newu(temp, 8, 24, c);
        for(int bit = 16; bit >=0; bit -=8){
            int b = getc(program);
            temp = Bitpack_newu(temp, 8, bit, b);
        }

        UM_Word* instr;
        NEW(instr);
        *instr = temp;
        Seq_addhi(words, instr);
        c = getc(program);
    }

    mapSegment(memorySegments, 0);
    mapInstructions(Seq_length(words));
    int length = instructionLength();

    for(int locToLoad = 0; locToLoad < length; locToLoad++){
        UM_Word* value = (UM_Word*)Seq_get(words, locToLoad);
        loadInstruction(locToLoad, *value);
        FREE(value);
    }

    Seq_free(&words);
}
Example #8
0
static void free_address_space(UM_machine machine)
{       
        UM_address_space address_space = machine->address_space;

        /* free the mapped segments sequence */
        int length = Seq_length(address_space->mapped_segments);
        for(int i=0; i<length; i++){
                UM_segment segment = Seq_remlo(address_space->mapped_segments);

                /* if segment with ID == i is mapped, free it */
                if(segment != NULL){
                        free_segment_memory(&segment);
                }
        }
        Seq_free(&address_space->mapped_segments);

        /* free the reusable IDs sequence */
        for(int i=0; i<Seq_length(address_space->reusable_IDs); i++){
                UM_segment_ID *seg_ID = 
                                       Seq_get(address_space->reusable_IDs, i);
                free(seg_ID);
        }
        Seq_free(&(address_space->reusable_IDs));

        free(address_space);
}
Example #9
0
File: kref.c Project: ZoneMo/backup
void kref(char *name, FILE *fp, Table_T identifiers) {
	char buf[512], *filename = "";
	int linenum;

	if (name)
		filename = name;
	for (linenum = 1; fgets(buf, sizeof buf, fp) != NULL; linenum++) {
		int i, j;
		for (i = 0; (j = getword(buf, &i, first, rest)) > 0; i = j) {
			char *id = Str_sub(buf, j, i);
			const char *ln = Atom_int(linenum);
			Seq_T seq;
			Table_T files;
			files = Table_get(identifiers, id);
			if (files == NULL) {
				files = Table_new(0,
					(int (*)(const void *, const void *))strcmp, strhash);
				Table_put(identifiers, id, files);
			} else
				FREE(id);
			seq = Table_get(files, filename);
			if (seq == NULL) {
				seq = Seq_new(0);
				Table_put(files, Str_dup(filename, 1, 0, 1), seq);
				Seq_addlo(seq, (void *)ln);
			} else if (Seq_get(seq, 0) != ln)
				Seq_addlo(seq, (void *)ln);
		}
	}
}
Example #10
0
/* load the val at myMem[rb][rc] */
uint32_t load_segment(Mem myMem, uint32_t rb, uint32_t rc)
{
	assert(myMem != NULL);
	Segment_T seg = (Segment_T) Seq_get(myMem->segs, rb);
	return Seg_get(seg, rc);
  
}
Example #11
0
/*
 * Copies and inserts the segment at the given ID into the Segment_Table
 * Parameters: sm - Segment manager struct
 * 	       id - ID of segment to copy
 * Return value: The id of the newly inserted segment
 */
unsigned copy_Segment(Segment_Manager sm, unsigned id)
{
	Segment original = Seq_get(sm->Segment_Table, id);
	unsigned length = UArray_length(original);
	Segment copy = UArray_copy(original, length);
	return insert_Segment(sm, copy);
}
Example #12
0
bool put_word(Segment s, uint32_t ID, uint32_t address, uint32_t word)
{
	TRY
	        assert(s);
	        UArray_T inner = Seq_get(s, ID);
	        
	        assert(inner);

		if (ID >= (unsigned) Seq_length(s)) {
			/* ID does not exist */
			return false;
		}

		if (address >= (unsigned) UArray_length(inner)) {
			/* offset does not exist */
			return false;
		}

	        assert(inner);

	        uint32_t *wordptr = UArray_at(inner, address);

	        *wordptr = word;

	EXCEPT(Mem_Failed)
		return false;
	END_TRY;

        return true;

}
Example #13
0
/* 
 * Input:   Mem_T structure, unsigned integer
 * Ouput:   void
 * Purpose: Copies the segment located at segIndex and stores it in segment 0 
 *          The segment previously at index 0 is freed.
 */
void load_program(Mem_T memory, unsigned segIndex)
{
        /*Segment that will become new program*/
        Seq_T program_to_load_temp = Seq_get(memory->segment_seq, segIndex);

        int length = Seq_length(program_to_load_temp);

        /*New sequence that will be put in segment 0*/
        Seq_T program_to_load = Seq_new(length);
        /*Copies program_to_load_temp to program_to_load*/
        for(int i = 0; i < length; i++) {
                Seq_addhi(program_to_load, Seq_get(program_to_load_temp, i));
        }
        Seq_T old_program = Seq_put(memory->segment_seq, 0, program_to_load);
        Seq_free(&old_program);
}
Example #14
0
/* store the val into myMem[rb][rc] */
void store_segment(Mem myMem, uint32_t ra, uint32_t rb, uint32_t val)
{

	assert(myMem != NULL);
	Segment_T seg = (Segment_T) Seq_get(myMem->segs, ra);
	Seg_put(seg, rb, val);
	return;
}
Example #15
0
/* Unmaps identified segment from memory, allows unchecked runtime error if
 * segment doesn't exist.
 */
void Segment_unmap(T seg_memory, ID_SIZE id)
{
        WORD_SIZE *temp;

        Seq_addlo(seg_memory->unmapped_ids, (void *)(uintptr_t)id);
        temp = Seq_get(seg_memory->segments, id);
        free(temp);
        Seq_put(seg_memory->segments, id, NULL);
}
Example #16
0
/* 
 * Input:  Mem_T structure, 32 bit word, unsigned segment index and an unsigned
 *         offset
 * Output: void
 * Purpose: Puts a word into a segment in memory at index segIndex with an 
 *          offset. Used to execute the segmented store instruction and to put
 *          put words into segment 0 during initialization
 */ 
void store_word(Mem_T memory, uint32_t word, unsigned segIndex, unsigned 
                                                                        offset)
{       
        Seq_T segment = (Seq_T)Seq_get(memory->segment_seq, segIndex);

        assert(segment != NULL);

        Seq_put(segment, offset, (void *)(uintptr_t)word);
        Seq_put(memory->segment_seq, segIndex, segment);
}
Example #17
0
void test_move()
{

        move_seg(SEG_LENGTH, SEG_LENGTH+1);

        Segment t1 = get_seg(SEG_LENGTH);
        Segment t2 = get_seg(SEG_LENGTH+1);

        for (unsigned i = 0; i < SEG_LENGTH; i++) {

                uint32_t *w = Seq_get(t1->data, i);
                uint32_t *w2 = Seq_get(t2->data, i);
                if (w != w2)
                        printf("TEST MOVE IS A FAIL!!!!!\n");
        }

        printf("TEST MOVE IS A FAIL!!!!!\n");

}
Example #18
0
__declspec(dllexport) void curl_shim_free_strings(void* p)
{
    int i, count;
    Seq_T seq = (Seq_T)p;
    
    count = Seq_length(seq);
    for (i = 0; i < count; i++)
        free(Seq_get(seq, i));
    Seq_free(&seq);
}
Example #19
0
/* 
 * Input: Mem_T structure
 * Output: void
 * Purpose: Frees all memory. Frees each segment, the sequence of segments,   
 *          the sequence of reusable indices and the pointer to the memory 
 *          structure
 */
void MemT_free(Mem_T memory){
        int length = Seq_length(memory->segment_seq);
        for(int i = 0; i < length; i++){
                Seq_T segment = Seq_get(memory->segment_seq, i);
                if(segment != NULL)
                        Seq_free(&segment);
        }
        Seq_free(&(memory->segment_seq));
        Seq_free(&(memory->reusable_indices));        
        free(memory);
}
Example #20
0
File: stab.c Project: bhanug/cdb
/* stabend - emits the symbol table */
static void stabend(Coordinate *cp, Symbol symroot, Coordinate *cpp[], Symbol sp[], Symbol *ignore) {
	Symbol addresses;
	int naddresses, nmodule;

	{	/* annotate top-level symbols */
		Symbol p;
		for (p = symroot; p != NULL; p = up(p->up))
			symboluid(p);
		pickle->globals = symboluid(symroot);
	}
	{	/* emit addresses of top-level and static symbols */
		int i, lc = 0, count = Seq_length(statics);
		addresses = genident(STATIC, array(voidptype, 1, 0), GLOBAL);
		comment("addresses:\n");
		defglobal(addresses, LIT);
		for (i = 0; i < count; i++) {
			Symbol p = Seq_get(statics, i);
			lc = emit_value(lc, voidptype, p);
		}
		lc = pad(maxalign, lc);
		naddresses = lc;
		Seq_free(&statics);
	}
	{	/* emit bp count as an alias for the module */
		Symbol spoints = mksymbol(AUTO,
			stringf("_spoints_V%x_%d", uname, Seq_length(pickle->spoints)),
			array(unsignedtype, 0, 0));
		spoints->generated = 1;
		defglobal(spoints, LIT);
	}
	{	/* emit module */
		int lc;
		comment("module:\n");
		defglobal(module, LIT);
		lc = emit_value( 0, unsignedtype, (unsigned long)uname);
		lc = emit_value(lc, voidptype, addresses);
		lc = pad(maxalign, lc);
		nmodule = lc;
	}
	Seq_free(&locals);
#define printit(x) fprintf(stderr, "%7d " #x "\n", n##x); total += n##x
	{
		int total = 0;
		printit(addresses);
		printit(module);
		fprintf(stderr, "%7d bytes total\n", total);
	}
#undef printit
	{	/* complete and write symbol-table pickle */
		FILE *f = fopen(stringf("%d.pickle", uname), "wb");
		sym_write_module(pickle, f);
		fclose(f);
	}
}
Example #21
0
/* free the mem */
void free_mem(Mem* myMem)
{
	assert(myMem != NULL);
	for (int i = 0; i < Seq_length((*myMem)->segs); i++) {
		Seg_free(Seq_get((*myMem)->segs, i));
	}
	
	Seq_free(&((*myMem)->segs));
	Stack_free(&((*myMem)->unmapped));
	free(*myMem);
}
Example #22
0
/*
 * Sets the value of segment[id][offset] to the given value
 * Parameters: sm 	- Segment manager struct
 * 	       id 	- ID of segment to set
 *	       offset	- Offset within the segment
 *	       value 	- Value to set
 * Return value: the old value of the specified segment[id][offset]
 */
uint32_t seg_Set(Segment_Manager sm, 
		 unsigned id,
		 unsigned offset,
		 uint32_t value)
{
	uint32_t old_value;
	Segment segment = Seq_get(sm->Segment_Table, id);
	uint32_t *location = UArray_at(segment, offset);
	old_value = *location;
	*location = value;
	return old_value;
}
Example #23
0
/* Frees all segmented memory created by the program, including the segment
 * where the program is stored.
 */
void Segment_free(T * seg_memory) {
        int len = Seq_length((*seg_memory)->segments);
        int i;

        for (i = 0; i < len; i++) {
                free(Seq_get((*seg_memory)->segments, i));
        }

        Seq_free(&((*seg_memory)->segments));
        Seq_free(&((*seg_memory)->unmapped_ids));
        free (*seg_memory);
}
Example #24
0
void  Segmem_free(T segmem)
{       
        int i;
        for(i = 0; i < segmem->length; i++)
        {
                int *array = (int *)Seq_get(segmem->memory, i);
                //printf("%p\n", (void *)(array));

                free(array);
        }
        Seq_free(&(segmem->memory));
}
Example #25
0
static int checkuid(list_ty list) {
	int i, n = 0, count = Seq_length(list);

	for (i = 0; i < count; i++) {
		rcc_interface_ty in = Seq_get(list, i);
		if (in->kind == rcc_Local_enum
		||  in->kind == rcc_Address_enum)
			n++;
		else if (in->kind == rcc_Function_enum)
			n += checkuid(in->v.rcc_Function.codelist);
	}
	return n;
}
Example #26
0
UArray_T get_seg(Segment s, uint32_t ID)
{
	assert(s);

	if (ID > (uint32_t) Seq_length(s)) {
		/* segment does not exist */
		return NULL;
	}

	UArray_T inner = Seq_get(s, ID);
	return inner;

}
Example #27
0
/* frees all of the segments and their contents */
void free_all(Segment outer)
{
	assert(outer);

	int num_segs = Seq_length(outer);

	for (int i = 0; i < num_segs; i++) {
		UArray_T inner = Seq_get(outer, i);
		UArray_free(&inner);
	}

	Seq_free(&outer);
}
Example #28
0
void check_map_capcity(){

//These variable created for compiling sake
	Seq_T SEG_MEMORY = Seq_new(100);
	Seq_T UNMAP_SEQ = Seq_new(10);

	for (int i = 0; i < 2000; i++){
		int size = rand() % 20;
		Umsegment_Id id = map_segment(size);
		(void) id;
		if (Seq_get(SEG_MEMORY, i) == NULL)
			fprintf(stderr, "Segment %d not mapped.\n", size);
		i++;
	}
	for (int j = 1999; j >= 0; j--){
		unmap_segment((Umsegment_Id) j);
		if (Seq_get(SEG_MEMORY, j) != NULL)
			fprintf(stderr, "Segment %d not unmapped.\n", j);
	}

	Seq_free(&SEG_MEMORY);
	Seq_free(&UNMAP_SEQ);
}
Example #29
0
/* returns the word stored at index address in the segment with id ID */
uint32_t get_word(Segment s, uint32_t ID, uint32_t address)
{
	assert(s);

	if(ID != 0 ){
		assert((signed) ID < get_num_segs(s));
	}
	
	UArray_T inner = Seq_get(s, ID);
	assert(inner);

	uint32_t *wordptr = UArray_at(inner, address);

	return *wordptr;
}
Example #30
0
extern void Um_write_sequence(FILE *output, Seq_T stream)
{
    // use w+ to open and clear the file
    FILE *hexOut = fopen("hex.out", "a");
    fprintf(hexOut, "STARTING NEW TEST SEQUENCE \n\n\n");
    int i, j, instrByte;
    int len = Seq_length(stream);
    for (i = 0; i < len; i++) {
        Um_instruction instr = (uint32_t)(uintptr_t)Seq_get(stream, i);
        for (j = 24; j >= 0; j -= BITS_PER_BYTE) {
            instrByte = (int)Bitpack_getu((uint64_t)instr, BITS_PER_BYTE, j);
            fputc(instrByte, output);
            fprintf(hexOut, "%02x ", instrByte);
        }
        fprintf(hexOut, "\n");
    }
}