Esempio n. 1
0
void MachOObject::load()
{
	if (isLoaded())
		throw std::logic_error("Module already loaded");
	if (strcmp(m_file->platform(), ARCH_NAME) != 0)
	{
		std::stringstream ss;
		ss << "This version of Darling dyld cannot load binaries for " << m_file->platform() << ".";
		throw std::runtime_error(ss.str());
	}
	
	loadSegments();
	transitionState(dyld_image_state_mapped);
	
	if (m_slide > 0)
		rebase();
	transitionState(dyld_image_state_rebased);
	
	readSymbols();
	readExports();

	MachOMgr::instance()->add(this, isMainModule());

	loadDependencies();
	
	performRelocations();
	performBinds();
	transitionState(dyld_image_state_bound);
	transitionState(dyld_image_state_dependents_initialized);
	
	// registerEHSection();
	
	if (isMainModule())
		fillInProgramVars();
	fillInDyldData();
	
	setInitialSegmentProtection();
	setupTLS();
	
	MachOMgr::instance()->notifyAdd(this);
	runInitializers();

	transitionState(dyld_image_state_initialized);
	
	m_file->closeFd();
	
	if (MachOMgr::instance()->printLibraries())
		std::cerr << "dyld: Loaded " << this->path() << std::endl;
}
Esempio n. 2
0
int main(){
	int i = 0;
	clearScr();
	writeScr("Initializing OS", 0, 0);
	writeScr("Setting up OS descriptors...", 1, 0);

	constructGDT();
	lgdtT.offset = (uint32_t) &gdt;
	lgdtT.limit = (sizeof(struct gdt_entry)*5) - 1;
	loadGDT(&lgdtT);

	constructIDT();
	lidtT.offset = (uint32_t) &idt;
	lidtT.limit = (sizeof(struct idt_entry)*256) - 1;
	loadIDT(&lidtT);
	
	asm("cli");
	setupPIC();

	uint8_t cs = 8;
	uint8_t ds = 16; 
	uint8_t ss = 24;
	uint8_t fs = ds; 
	uint8_t es = 32;

	loadSegments(cs,ds,ss,fs,es);
	
	writeScrPM("done.", 2, 28);
	clearScrPM();
	head = null;
	tail = null;

  	writeScrPM("Running ten processes...", 0, 0);
	writeScrPM("-          -", 20, 0);
	mutex_init(&m);

	// Process 1
	createProcess(ds,  ss, stack[0] + STACK_SIZE, cs, (uint32_t) p1);
	
	// Process 2
	createProcess(ds,  ss, stack[1] + STACK_SIZE, cs, (uint32_t) p2);
	
	// Process 3
	createProcess(ds,  ss, stack[2] + STACK_SIZE, cs, (uint32_t) p3);
	
	// Process 4
	createProcess(ds,  ss, stack[3] + STACK_SIZE, cs, (uint32_t) p4);
	
	// Process 5
	createProcess(ds,  ss, stack[4] + STACK_SIZE, cs, (uint32_t) p5);
	
	// Process 6
	createProcess(ds,  ss, stack[5] + STACK_SIZE, cs, (uint32_t) p6);
	
	// Process 7
	createProcess(ds,  ss, stack[6] + STACK_SIZE, cs, (uint32_t) p7);
	// Process 8
	createProcess(ds,  ss, stack[7] + STACK_SIZE, cs, (uint32_t) p8);
	// Process 9
	createProcess(ds,  ss, stack[8] + STACK_SIZE, cs, (uint32_t) p9);
	// Process 10
	createProcess(ds,  ss, stack[9] + STACK_SIZE, cs, (uint32_t) p10);
	//*/
	start();
}