virtual void start_neuron ()
{
data_stream::start_neuron();
sections.reset(new
bbp::Sections(n_i->morphology().all_sections()));
s_i = sections->begin();
s_e = sections->end();
init_segments();
}
void advance_section ()
{
s_i++;
if (s_i == s_e)
{
advance_neuron();
return;
}
init_segments();
}
value caml_startup_common(char_os **argv, int pooling)
{
char_os * exe_name, * proc_self_exe;
char tos;
CAML_INIT_DOMAIN_STATE;
/* Determine options */
caml_parse_ocamlrunparam();
#ifdef DEBUG
caml_gc_message (-1, "### OCaml runtime: debug mode ###\n");
#endif
if (caml_params->cleanup_on_exit)
pooling = 1;
if (!caml_startup_aux(pooling))
return Val_unit;
#ifdef WITH_SPACETIME
caml_spacetime_initialize();
#endif
caml_init_ieee_floats();
#if defined(_MSC_VER) && __STDC_SECURE_LIB__ >= 200411L
caml_install_invalid_parameter_handler();
#endif
caml_init_custom_operations();
caml_init_gc ();
if (caml_params->backtrace_enabled_init)
caml_record_backtrace(Val_int(1));
/* Capture 16-byte aligned (ceil) system_stack_high */
Caml_state->system_stack_high =
(char*)((((uintnat)&tos + 16) >> 4) << 4);
init_segments();
caml_init_signals();
#ifdef _WIN32
caml_win32_overflow_detection();
#endif
caml_debugger_init (); /* force debugger.o stub to be linked */
exe_name = argv[0];
if (exe_name == NULL) exe_name = _T("");
proc_self_exe = caml_executable_name();
if (proc_self_exe != NULL)
exe_name = proc_self_exe;
else
exe_name = caml_search_exe_in_path(exe_name);
caml_init_argv(exe_name, argv);
if (sigsetjmp(caml_termination_jmpbuf.buf, 0)) {
if (caml_termination_hook != NULL) caml_termination_hook(NULL);
return Val_unit;
}
caml_init_main_stack();
return caml_start_program(Caml_state->young_ptr);
}
int elf32_register(struct edit_file *efile)
{
char *e_ident = efile->mmap;
uint16_t phoff;
int elfmach;
struct edit_segment *segs;
int i;
if(efile->flags & FL_NEW) {
if(efile->objtype == OBJ_ELF32) {
log(LOG_LOW, "Creating a new elf32 file '%s'\n", efile->filename);
efile->write_file = elf32_write;
efile->pagesize = elfarch_pagesize(efile->arch);
return 0;
} else {
return 1;
}
}
/* Check magic */
if(e_ident[0] != ELF_MAGIC_0 ||
e_ident[1] != ELF_MAGIC_1 ||
e_ident[2] != ELF_MAGIC_2 ||
e_ident[3] != ELF_MAGIC_3)
return 1;
if(e_ident[EI_CLASS] != ELFCLASS32)
return 1;
/* Possibly allow for old elf formats */
if(e_ident[EI_VERSION] != EV_CURRENT)
return 1;
/* Don't care whether or not it is executable. Let the user shoot
* themself in the foot, but somebody might want to do it someday */
/* File is a elf32, so set everything up */
efile->objtype = OBJ_ELF32;
if(e_ident[EI_DATA] == ELFDATA2LSB)
efile->endianness = LSB;
else if(e_ident[EI_DATA] == ELFDATA2MSB)
efile->endianness = MSB;
else {
log(LOG_WARNING, "Unknown endianness: %d\n", e_ident[EI_DATA]);
return 1;
}
elfmach = read16(offsetof(Elf32_Ehdr, e_machine) + efile->mmap,
efile->endianness);
efile->arch = elfmach2arch(elfmach);
efile->pagesize = elfarch_pagesize(efile->arch);
if(efile->arch == ARCH_INVALID) {
log(LOG_WARNING, "Unknown machine type: %d\n", elfmach);
return 1;
}
efile->write_file = elf32_write;
/* XXX: If we have an entry point, ignore the one in the file. */
if (efile->entry == 0)
efile->entry = read32(offsetof(Elf32_Ehdr, e_entry) + efile->mmap,
efile->endianness);
efile->nsegments = read16(offsetof(Elf32_Ehdr, e_phnum) + efile->mmap,
efile->endianness);
phoff = read32(offsetof(Elf32_Ehdr, e_phoff) + efile->mmap,
efile->endianness);
/* Read all sections in this file */
init_sections(efile);
/* Set up segment table */
segs = calloc(efile->nsegments, sizeof(struct edit_segment));
if(segs == NULL) {
log(LOG_CRITICAL, "calloc() failed\n");
exit(EXIT_FAILURE);
}
efile->nsegments = init_segments(efile->nsegments, segs, phoff, efile);
efile->segments = segs;
/* Align the file to the desired value */
i = efile->nsegments - 1;
segs = efile->segments;
segs[i].memsize = ALIGN(segs[i].memsize + segs[i].vaddr,
efile->alignment) - segs[i].vaddr;
efile->size = segs[i].vaddr + segs[i].memsize - segs[0].vaddr;
/* Fix the entry point. */
if (efile->flags & FL_PHYS_ENTRY && efile->nsegments) {
struct edit_section *current_section;
int i, done = 0;
for (i = 0; i < efile->nsegments; i++) {
edit_addr start = efile->segments[i].vaddr;
edit_addr end = efile->segments[i].vaddr + efile->segments[i].memsize;
if ((start <= efile->entry) && (efile->entry < end))
{
done = 1;
efile->entry = efile->segments[i].paddr +
(efile->entry - efile->segments[i].vaddr);
break;
}
}
/* If not found, just use seg 0 (probably will break) */
if (!done) {
efile->entry = efile->segments[0].paddr +
(efile->entry - efile->segments[0].vaddr);
}
/* Fix all section addresses */
for (current_section = efile->first_section; current_section != NULL;
current_section = current_section->next) {
done = 0;
for (i = 0; i < efile->nsegments; i++)
{
edit_addr start = efile->segments[i].vaddr;
edit_addr end = efile->segments[i].vaddr + efile->segments[i].memsize;
if ((start <= current_section->addr) && (current_section->addr < end)) {
done = 1;
current_section->addr -= (efile->segments[i].vaddr -
efile->segments[i].paddr);
break;
}
}
/* If not found, just use seg 0 (probably will break) */
if (!done) {
current_section->addr -= (efile->segments[0].vaddr -
efile->segments[0].paddr);
}
}
}
/* Set the correct header generator */
efile->elf_create_headers = elf32_create_headers;
efile->word_size = arch_to_wordsize(efile->arch);
return 0;
}
