1 | /* -*- c++ -*- |
---|
2 | * |
---|
3 | * GIET_VM_LGPL_HEADER_BEGIN |
---|
4 | * |
---|
5 | * This file is part of GIET_VM, GNU LGPLv2.1. |
---|
6 | * |
---|
7 | * GIET_VM is free software; you can redistribute it and/or modify it |
---|
8 | * under the terms of the GNU Lesser General Public License as published |
---|
9 | * by the Free Software Foundation; version 2.1 of the License. |
---|
10 | * |
---|
11 | * GIET_VM is distributed in the hope that it will be useful, but |
---|
12 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
---|
14 | * Lesser General Public License for more details. |
---|
15 | * |
---|
16 | * You should have received a copy of the GNU Lesser General Public |
---|
17 | * License along with GIET_VM; if not, write to the Free Software |
---|
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
---|
19 | * 02110-1301 USA |
---|
20 | * |
---|
21 | * GIET_VM_LGPL_HEADER_END |
---|
22 | * |
---|
23 | * Copyright (c) UPMC, Lip6, SoC |
---|
24 | * Mohamed Lamine KARAOUI <Mohamed.Karaoui@lip6.fr>, 2012 |
---|
25 | */ |
---|
26 | |
---|
27 | #include <string.h> |
---|
28 | #include <cassert> |
---|
29 | #include <sstream> |
---|
30 | #include <fstream> |
---|
31 | #include <ios> |
---|
32 | #include <iostream> |
---|
33 | #include <cstdarg> |
---|
34 | #include <cassert> |
---|
35 | #include <iomanip> |
---|
36 | |
---|
37 | |
---|
38 | #include "exception.h" |
---|
39 | #include "memo.h" |
---|
40 | |
---|
41 | //#define MOVER_DEBUG |
---|
42 | |
---|
43 | size_t PSeg::m_pageSize; |
---|
44 | |
---|
45 | |
---|
46 | //////////////////////////////////////////// |
---|
47 | MeMo::MeMo(const std::string &filename, |
---|
48 | const size_t pageSize) |
---|
49 | : m_path(filename), |
---|
50 | m_pathHandler(filename), |
---|
51 | m_ginit(false), |
---|
52 | m_generator(new elfpp::object()) |
---|
53 | { |
---|
54 | PSeg::setPageSize(pageSize); |
---|
55 | |
---|
56 | // loading map_info blob |
---|
57 | m_data = std::malloc(bin_size(m_path)); |
---|
58 | if ( !m_data ) |
---|
59 | throw exception::RunTimeError("malloc failed... No memory space"); |
---|
60 | |
---|
61 | m_size = load_bin(m_path, m_data); |
---|
62 | |
---|
63 | // checking signature |
---|
64 | mapping_header_t* header = (mapping_header_t*)m_data; |
---|
65 | if((IN_MAPPING_SIGNATURE != header->signature)) |
---|
66 | { |
---|
67 | std::cout << "wrong signature " |
---|
68 | << std::hex <<header->signature |
---|
69 | << ", should be:"<< IN_MAPPING_SIGNATURE << std::endl; |
---|
70 | exit(1); |
---|
71 | } |
---|
72 | |
---|
73 | #ifdef MOVER_DEBUG |
---|
74 | std::cout << "Binary file path: " << m_path << std::endl; |
---|
75 | print_mapping_info(m_data); |
---|
76 | #endif |
---|
77 | |
---|
78 | buildMap(m_data); |
---|
79 | |
---|
80 | #ifdef MOVER_DEBUG |
---|
81 | std::cout << "parsing done" << std::endl ; |
---|
82 | #endif |
---|
83 | |
---|
84 | #ifdef MOVER_DEBUG |
---|
85 | print_mapping(); |
---|
86 | std::cout << *this << std::endl; |
---|
87 | #endif |
---|
88 | |
---|
89 | m_psegh.check(); |
---|
90 | #ifdef MOVER_DEBUG |
---|
91 | std::cout << "checking done" << std::endl ; |
---|
92 | #endif |
---|
93 | |
---|
94 | } |
---|
95 | |
---|
96 | ///////////////////////////////////////// |
---|
97 | void MeMo::print(std::ostream &o) const |
---|
98 | { |
---|
99 | std::cout << "All sections:" << std::endl; |
---|
100 | FOREACH(sect, m_generator->get_section_table()) |
---|
101 | { |
---|
102 | assert(&*sect != NULL); |
---|
103 | std::cout << *sect << std::endl; |
---|
104 | } |
---|
105 | } |
---|
106 | |
---|
107 | //////////////////////////////// |
---|
108 | void MeMo::print_mapping() const |
---|
109 | { |
---|
110 | std::cout << m_psegh << std::endl; |
---|
111 | } |
---|
112 | |
---|
113 | //////////////////////////////////////////////////////////////////////////////// |
---|
114 | elfpp::section* MeMo::get_sect_by_addr(elfpp::object *loader, unsigned int addr) |
---|
115 | { |
---|
116 | FOREACH( sect, loader->get_section_table() ) |
---|
117 | { |
---|
118 | assert(&*sect != NULL); |
---|
119 | elfpp::sh_flags_e eflags = sect->get_flags(); |
---|
120 | if ( !(eflags & elfpp::SHF_ALLOC) ) |
---|
121 | continue; |
---|
122 | if(sect->get_load_address() == addr) //load_addr ? |
---|
123 | { |
---|
124 | return (&*sect); |
---|
125 | } |
---|
126 | } |
---|
127 | return NULL; |
---|
128 | } |
---|
129 | |
---|
130 | ///////////////////////////////////////////////// |
---|
131 | void MeMo::buildSoft(const std::string &filename) |
---|
132 | { |
---|
133 | if(!m_ginit) |
---|
134 | throw exception::RunTimeError(std::string("Can't get generator! ") ); |
---|
135 | |
---|
136 | m_generator->write(filename); |
---|
137 | |
---|
138 | } |
---|
139 | |
---|
140 | ///////////////////////////////////////////////////////// |
---|
141 | size_t MeMo::load_bin(std::string filename, void* buffer) |
---|
142 | { |
---|
143 | |
---|
144 | #ifdef MOVER_DEBUG |
---|
145 | std::cout << "Loading binary blob from file '" << filename << "'" << std::endl; |
---|
146 | #endif |
---|
147 | |
---|
148 | std::ifstream input(filename.c_str(), std::ios_base::binary|std::ios_base::in); |
---|
149 | |
---|
150 | if ( ! input.good() ) |
---|
151 | throw exception::RunTimeError(std::string("Can't open the file: ") + filename); |
---|
152 | |
---|
153 | input.seekg( 0, std::ifstream::end ); |
---|
154 | size_t size = input.tellg(); |
---|
155 | input.seekg( 0, std::ifstream::beg ); |
---|
156 | |
---|
157 | if ( !buffer ) |
---|
158 | throw exception::RunTimeError("Empty buffer!"); |
---|
159 | |
---|
160 | input.read( (char*)buffer, size ); |
---|
161 | |
---|
162 | input.close(); |
---|
163 | |
---|
164 | return size; |
---|
165 | } |
---|
166 | |
---|
167 | |
---|
168 | /* get the size of the content of the filename */ |
---|
169 | ////////////////////////////////////////// |
---|
170 | size_t MeMo::bin_size(std::string filename) |
---|
171 | { |
---|
172 | |
---|
173 | #ifdef MOVER_DEBUG |
---|
174 | std::cout << "Trying to get the size of the binary blob '" << filename << "'" << std::endl; |
---|
175 | #endif |
---|
176 | |
---|
177 | std::ifstream input(filename.c_str(), std::ios_base::binary|std::ios_base::in); |
---|
178 | |
---|
179 | if ( ! input.good() ) |
---|
180 | throw exception::RunTimeError(std::string("Can't open the file: ") + filename); |
---|
181 | |
---|
182 | input.seekg( 0, std::ifstream::end ); |
---|
183 | size_t size = input.tellg(); |
---|
184 | input.seekg( 0, std::ifstream::beg ); |
---|
185 | |
---|
186 | input.close(); |
---|
187 | |
---|
188 | return size; |
---|
189 | } |
---|
190 | |
---|
191 | |
---|
192 | ///////////// |
---|
193 | MeMo::~MeMo() |
---|
194 | { |
---|
195 | //std::cout << "Deleted MeMo " << *this << std::endl; |
---|
196 | //std::free(m_data);//should be done by the elfpp driver since we passed the pointer |
---|
197 | std::map<std::string, elfpp::object*>::iterator l; |
---|
198 | for(l = m_loaders.begin(); l != m_loaders.end(); l++) |
---|
199 | { |
---|
200 | delete (*l).second; |
---|
201 | } |
---|
202 | //delete m_generator; |
---|
203 | } |
---|
204 | |
---|
205 | |
---|
206 | ///////////////////////////////////////////////////////////////////////////// |
---|
207 | // various mapping_info data structure access functions |
---|
208 | ///////////////////////////////////////////////////////////////////////////// |
---|
209 | mapping_cluster_t* MeMo::get_cluster_base( mapping_header_t* header ) |
---|
210 | { |
---|
211 | return (mapping_cluster_t*) ((char*)header + |
---|
212 | MAPPING_HEADER_SIZE); |
---|
213 | } |
---|
214 | ///////////////////////////////////////////////////////////////////////////// |
---|
215 | mapping_pseg_t* MeMo::get_pseg_base( mapping_header_t* header ) |
---|
216 | { |
---|
217 | return (mapping_pseg_t*) ((char*)header + |
---|
218 | MAPPING_HEADER_SIZE + |
---|
219 | MAPPING_CLUSTER_SIZE*header->clusters); |
---|
220 | } |
---|
221 | ///////////////////////////////////////////////////////////////////////////// |
---|
222 | mapping_vspace_t* MeMo::get_vspace_base( mapping_header_t* header ) |
---|
223 | { |
---|
224 | return (mapping_vspace_t*) ((char*)header + |
---|
225 | MAPPING_HEADER_SIZE + |
---|
226 | MAPPING_CLUSTER_SIZE*header->clusters + |
---|
227 | MAPPING_PSEG_SIZE*header->psegs); |
---|
228 | } |
---|
229 | ///////////////////////////////////////////////////////////////////////////// |
---|
230 | mapping_vseg_t* MeMo::get_vseg_base( mapping_header_t* header ) |
---|
231 | { |
---|
232 | return (mapping_vseg_t*) ((char*)header + |
---|
233 | MAPPING_HEADER_SIZE + |
---|
234 | MAPPING_CLUSTER_SIZE*header->clusters + |
---|
235 | MAPPING_PSEG_SIZE*header->psegs + |
---|
236 | MAPPING_VSPACE_SIZE*header->vspaces); |
---|
237 | } |
---|
238 | ///////////////////////////////////////////////////////////////////////////// |
---|
239 | mapping_vobj_t* MeMo::get_vobj_base( mapping_header_t* header ) |
---|
240 | { |
---|
241 | return (mapping_vobj_t*) ((char*)header + |
---|
242 | MAPPING_HEADER_SIZE + |
---|
243 | MAPPING_CLUSTER_SIZE*header->clusters + |
---|
244 | MAPPING_PSEG_SIZE*header->psegs + |
---|
245 | MAPPING_VSPACE_SIZE*header->vspaces + |
---|
246 | MAPPING_VSEG_SIZE*header->vsegs); |
---|
247 | } |
---|
248 | |
---|
249 | ///////////////////////////////////////////////////////////////////////////// |
---|
250 | // print the content of the mapping_info data structure |
---|
251 | //////////////////////////////////////////////////////////////////////// |
---|
252 | void MeMo::print_mapping_info(void* desc) |
---|
253 | { |
---|
254 | mapping_header_t* header = (mapping_header_t*)desc; |
---|
255 | |
---|
256 | mapping_pseg_t* pseg = get_pseg_base( header );; |
---|
257 | mapping_vspace_t* vspace = get_vspace_base ( header );; |
---|
258 | mapping_vseg_t* vseg = get_vseg_base ( header ); |
---|
259 | mapping_vobj_t* vobj = get_vobj_base ( header ); |
---|
260 | |
---|
261 | // header |
---|
262 | std::cout << std::hex << "mapping_info" << std::dec << std::endl |
---|
263 | << " + signature = " << header->signature << std::endl |
---|
264 | << " + name = " << (char*)header->name << std::endl |
---|
265 | << " + clusters = " << header->clusters << std::endl |
---|
266 | << " + psegs = " << header->psegs << std::endl |
---|
267 | << " + vspaces = " << header->vspaces << std::endl |
---|
268 | << " + globals = " << header->globals << std::endl |
---|
269 | << " + vsegs = " << header->vsegs << std::endl |
---|
270 | << " + vobjs = " << header->vsegs << std::endl |
---|
271 | << " + tasks = " << header->tasks << std::endl; |
---|
272 | |
---|
273 | // psegs |
---|
274 | for ( size_t pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ ) |
---|
275 | { |
---|
276 | std::cout << "pseg " << pseg[pseg_id].name << std::hex << std::endl |
---|
277 | << " + base = " << pseg[pseg_id].base << std::endl |
---|
278 | << " + length = " << pseg[pseg_id].length << std::endl ; |
---|
279 | } |
---|
280 | |
---|
281 | // globals |
---|
282 | for ( size_t vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ ) |
---|
283 | { |
---|
284 | std::cout << std::endl; |
---|
285 | //std::cout << vseg[vseg_id].psegid << std::endl; |
---|
286 | std::cout << "global vseg " << vseg[vseg_id].name << std::hex << std::endl |
---|
287 | << " + vbase = " << vseg[vseg_id].vbase << std::endl |
---|
288 | << " + length = " << vseg[vseg_id].length << std::endl |
---|
289 | << " + mode = " << (size_t)vseg[vseg_id].mode << std::endl |
---|
290 | << " + ident = " << (bool)vseg[vseg_id].ident << std::endl |
---|
291 | << " + psegname = " << pseg[vseg[vseg_id].psegid].name << std::endl; |
---|
292 | for( size_t vobj_id = vseg[vseg_id].vobj_offset ; |
---|
293 | vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; |
---|
294 | vobj_id++ ) |
---|
295 | { |
---|
296 | std::cout << "\t vobj " << vobj[vobj_id].name << std::endl |
---|
297 | << "\t + index = " << std::dec << vobj_id << std::endl |
---|
298 | << "\t + type = " << vobj[vobj_id].type << std::endl |
---|
299 | << "\t + length = " << vobj[vobj_id].length << std::endl |
---|
300 | << "\t + align = " << vobj[vobj_id].align << std::endl |
---|
301 | << "\t + binpath = " << vobj[vobj_id].binpath << std::endl |
---|
302 | << "\t + init = " << vobj[vobj_id].init << std::endl; |
---|
303 | } |
---|
304 | } |
---|
305 | |
---|
306 | // vspaces |
---|
307 | for ( size_t vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ ) |
---|
308 | { |
---|
309 | std::cout << "***vspace " << vspace[vspace_id].name << std::endl |
---|
310 | << " + vsegs = " << vspace[vspace_id].vsegs << std::endl |
---|
311 | << " + vobjs = " << vspace[vspace_id].vobjs << std::endl |
---|
312 | << " + tasks = " << vspace[vspace_id].tasks << std::endl; |
---|
313 | |
---|
314 | for ( size_t vseg_id = vspace[vspace_id].vseg_offset ; |
---|
315 | vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs) ; |
---|
316 | vseg_id++ ) |
---|
317 | { |
---|
318 | std::cout << "\t vseg " << vseg[vseg_id].name << std::endl |
---|
319 | << "\t + vbase = " << vseg[vseg_id].vbase << std::endl |
---|
320 | << "\t + length = " << vseg[vseg_id].length << std::endl |
---|
321 | << "\t + mode = " << (size_t)vseg[vseg_id].mode << std::endl |
---|
322 | << "\t + ident = " << (bool)vseg[vseg_id].ident << std::endl |
---|
323 | << "\t + psegname = " << pseg[vseg[vseg_id].psegid].name << std::endl; |
---|
324 | for(size_t vobj_id = vseg[vseg_id].vobj_offset ; |
---|
325 | vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; |
---|
326 | vobj_id++ ) |
---|
327 | { |
---|
328 | std::cout << "\t\t vobj " << vobj[vobj_id].name << std::endl |
---|
329 | << "\t\t + index = " << std::dec << vobj_id << std::endl |
---|
330 | << "\t\t + type = " << vobj[vobj_id].type << std::endl |
---|
331 | << "\t\t + length = " << vobj[vobj_id].length << std::endl |
---|
332 | << "\t\t + align = " << vobj[vobj_id].align << std::endl |
---|
333 | << "\t\t + binpath = " << vobj[vobj_id].binpath << std::endl |
---|
334 | << "\t\t + init = " << vobj[vobj_id].init << std::endl; |
---|
335 | } |
---|
336 | } |
---|
337 | |
---|
338 | } |
---|
339 | } // end print_mapping_info() |
---|
340 | |
---|
341 | |
---|
342 | ////////////////////////////////////////// |
---|
343 | void MeMo::vseg_map( mapping_vseg_t* vseg) |
---|
344 | { |
---|
345 | mapping_vobj_t * vobj = get_vobj_base((mapping_header_t*) m_data ); |
---|
346 | PSeg * ps = &(m_psegh.get(vseg->psegid)); |
---|
347 | elfpp::section * sect = NULL; |
---|
348 | size_t cur_vaddr; |
---|
349 | paddr_t cur_length; |
---|
350 | bool first = true; |
---|
351 | bool aligned = false; |
---|
352 | VSeg * vSO = new VSeg; |
---|
353 | mapping_vobj_t * cur_vobj; |
---|
354 | |
---|
355 | vSO->m_name = std::string(vseg->name); |
---|
356 | vSO->m_vma = vseg->vbase; |
---|
357 | vSO->m_lma = 0; |
---|
358 | |
---|
359 | cur_vaddr = vseg->vbase; |
---|
360 | cur_length = 0; // curr_length of the vseg; a new vseg is necessarily aligned on a page boundary |
---|
361 | |
---|
362 | #ifdef MOVER_DEBUG |
---|
363 | std::cout << "--------------- vseg_map "<< vseg->name <<" ------------------" << std::endl; |
---|
364 | #endif |
---|
365 | |
---|
366 | for (size_t vobj_id = vseg->vobj_offset; |
---|
367 | vobj_id < (vseg->vobj_offset + vseg->vobjs); vobj_id++) |
---|
368 | { |
---|
369 | cur_vobj = &vobj[vobj_id]; |
---|
370 | |
---|
371 | #ifdef MOVER_DEBUG |
---|
372 | std::cout << std::hex << "current vobj("<< vobj_id <<"): " << cur_vobj->name |
---|
373 | << " (" <<cur_vobj->vaddr << ")" |
---|
374 | << " size: "<< cur_vobj->length |
---|
375 | << " type: " << cur_vobj->type << std::endl; |
---|
376 | #endif |
---|
377 | if (cur_vobj->type == VOBJ_TYPE_BLOB) |
---|
378 | { |
---|
379 | size_t blob_size; |
---|
380 | std::string filePath(m_pathHandler.getFullPath(std::string(cur_vobj->binpath))); |
---|
381 | |
---|
382 | #ifdef MOVER_DEBUG |
---|
383 | std::cout << std::hex << "Handling: " << filePath << " ..." << std::endl; |
---|
384 | #endif |
---|
385 | |
---|
386 | if (!filePath.compare(m_path)) // local blob: map_info |
---|
387 | { |
---|
388 | #ifdef MOVER_DEBUG |
---|
389 | std::cout << "Found the vseg of the mapping info" << std::endl; |
---|
390 | #endif |
---|
391 | blob_size = this->m_size; |
---|
392 | assert((blob_size >0) and "MAPPING INFO file is empty !?"); |
---|
393 | } |
---|
394 | else |
---|
395 | { |
---|
396 | #ifdef MOVER_DEBUG |
---|
397 | std::cout << "Found an BLOB vseg" << std::endl; |
---|
398 | #endif |
---|
399 | blob_size = bin_size(filePath); |
---|
400 | } |
---|
401 | |
---|
402 | // creating a new section |
---|
403 | sect = new elfpp::section(*m_generator, elfpp::SHT_PROGBITS); |
---|
404 | |
---|
405 | sect->set_name(std::string(cur_vobj->name)); |
---|
406 | sect->set_flags(elfpp::SHF_ALLOC | elfpp::SHF_WRITE); |
---|
407 | sect->set_size(blob_size); //do the malloc for the get_content fonction |
---|
408 | |
---|
409 | assert(sect->get_content());//check allocation |
---|
410 | |
---|
411 | if (!filePath.compare(m_path)) { //local blob: map_info |
---|
412 | //memcpy(sect->get_content(), m_data, sect->get_size()); |
---|
413 | /* this way the modification of the elf size are propageted to the giet */ |
---|
414 | sect->set_content(this->m_data); |
---|
415 | } |
---|
416 | else |
---|
417 | { |
---|
418 | load_bin(filePath, sect->get_content()); |
---|
419 | } |
---|
420 | |
---|
421 | |
---|
422 | if (blob_size > cur_vobj->length) |
---|
423 | { |
---|
424 | std::cout << std::hex << "!!! Warning, specified blob type vobj ("<< |
---|
425 | cur_vobj->name <<") size is "<< cur_vobj->length << ", the actual size is " |
---|
426 | << blob_size << " !!!" <<std::endl; |
---|
427 | assert(0 and "blob vobj length smaller than the actual content" );//??? |
---|
428 | } |
---|
429 | |
---|
430 | cur_vobj->length = blob_size; //set the true size of this BLOB vobj |
---|
431 | |
---|
432 | vSO->m_file = filePath; |
---|
433 | vSO->m_loadable = true; |
---|
434 | } |
---|
435 | else if (cur_vobj->type == VOBJ_TYPE_ELF) |
---|
436 | { |
---|
437 | if (!first) |
---|
438 | throw exception::RunTimeError(std::string("elf vobj type, must be placed first in a vseg")); |
---|
439 | |
---|
440 | size_t elf_size; |
---|
441 | std::string filePath(m_pathHandler.getFullPath(std::string(cur_vobj->binpath))); |
---|
442 | #ifdef MOVER_DEBUG |
---|
443 | std::cout << "Handling: " << filePath << " ..." << std::endl; |
---|
444 | std::cout << "Found an ELF vseg" << std::endl; |
---|
445 | #endif |
---|
446 | if (m_loaders.count(filePath) == 0) |
---|
447 | m_loaders[filePath] = new elfpp::object(filePath); |
---|
448 | elfpp::object * loader = m_loaders[filePath]; //TODO:free!? |
---|
449 | |
---|
450 | sect = new elfpp::section(*get_sect_by_addr(loader, cur_vaddr)); //copy: for the case we replicate the code |
---|
451 | if (!sect) |
---|
452 | { |
---|
453 | std::cerr << "No section found for " << cur_vobj->name << " at "<< cur_vaddr << std::endl; |
---|
454 | exit(-1); |
---|
455 | } |
---|
456 | |
---|
457 | sect->set_name(std::string(cur_vobj->name)); |
---|
458 | |
---|
459 | |
---|
460 | elf_size = sect->get_size(); |
---|
461 | assert((elf_size > 0) and "ELF section empty ?"); |
---|
462 | |
---|
463 | if (!m_ginit) |
---|
464 | { |
---|
465 | /** Initailising the header of the generator from the first binary, |
---|
466 | ** we suppose that the header is the same for all the binarys **/ |
---|
467 | m_generator->copy_info(*loader, 64); |
---|
468 | m_ginit = true; |
---|
469 | } |
---|
470 | |
---|
471 | if (elf_size > cur_vobj->length) |
---|
472 | { |
---|
473 | std::cout << "Warning, specified elf type vobj (" << |
---|
474 | cur_vobj->name << ") size is " << cur_vobj->length << ", the actual size is " |
---|
475 | << elf_size << std::endl; |
---|
476 | assert((0) and "elf vobj length smaller than the actual content"); |
---|
477 | } |
---|
478 | |
---|
479 | cur_vobj->length = elf_size;//set the true size of this ELF vobj |
---|
480 | |
---|
481 | vSO->m_file = filePath; |
---|
482 | vSO->m_loadable = true; |
---|
483 | } |
---|
484 | |
---|
485 | //aligning the vobj->paddr if necessary |
---|
486 | if (cur_vobj->align) |
---|
487 | { |
---|
488 | cur_length = PSeg::align(cur_length, cur_vobj->align); |
---|
489 | aligned = true; |
---|
490 | } |
---|
491 | |
---|
492 | cur_vaddr += cur_vobj->length; |
---|
493 | cur_length += cur_vobj->length; |
---|
494 | first = false; |
---|
495 | } |
---|
496 | |
---|
497 | assert(cur_vaddr >= vseg->vbase); |
---|
498 | |
---|
499 | vSO->m_length = cur_length; //pageAlign is done by the psegs |
---|
500 | vSO->m_ident = vseg->ident; |
---|
501 | vSO->m_align = vobj[vseg->vobj_offset].align; |
---|
502 | |
---|
503 | //set the lma for vseg that are not peripherals |
---|
504 | if (ps->type() != PSEG_TYPE_PERI) |
---|
505 | { |
---|
506 | if (vseg->ident != 0) ps->addIdent(*vSO); |
---|
507 | else ps->add(*vSO); |
---|
508 | } |
---|
509 | |
---|
510 | if (!sect) return; |
---|
511 | |
---|
512 | #ifdef MOVER_DEBUG |
---|
513 | std::cout << "section: "<< *sect <<"\n seted to: " << (*vSO) << std::endl; |
---|
514 | #endif |
---|
515 | |
---|
516 | sect->set_vaddr((*vSO).lma()); |
---|
517 | m_generator->add_section(*sect); |
---|
518 | |
---|
519 | } // end vseg_map() |
---|
520 | |
---|
521 | |
---|
522 | /////////////////////////////// |
---|
523 | void MeMo::buildMap(void * desc) |
---|
524 | { |
---|
525 | mapping_header_t * header = (mapping_header_t *) desc; |
---|
526 | |
---|
527 | mapping_cluster_t * cluster = get_cluster_base(header); |
---|
528 | mapping_vspace_t * vspace = get_vspace_base(header); |
---|
529 | mapping_pseg_t * pseg = get_pseg_base(header); |
---|
530 | mapping_vseg_t * vseg = get_vseg_base(header); |
---|
531 | |
---|
532 | // get the psegs |
---|
533 | |
---|
534 | #ifdef MOVER_DEBUG |
---|
535 | std::cout << "\n******* Storing Pseg information *********\n" << std::endl; |
---|
536 | #endif |
---|
537 | |
---|
538 | for (size_t cluster_id = 0; cluster_id < header->clusters; cluster_id++) { |
---|
539 | for (size_t pseg_id = cluster[cluster_id].pseg_offset; |
---|
540 | pseg_id < cluster[cluster_id].pseg_offset + cluster[cluster_id].psegs; |
---|
541 | pseg_id++) { |
---|
542 | std::string name(pseg[pseg_id].name); |
---|
543 | PSeg *ps = new PSeg(name, |
---|
544 | pseg[pseg_id].base, |
---|
545 | pseg[pseg_id].length, |
---|
546 | pseg[pseg_id].type); |
---|
547 | m_psegh.m_pSegs.push_back(*ps); |
---|
548 | } |
---|
549 | } |
---|
550 | |
---|
551 | // map global vsegs |
---|
552 | |
---|
553 | #ifdef MOVER_DEBUG |
---|
554 | std::cout << "\n******* mapping global vsegs *********\n" << std::endl; |
---|
555 | #endif |
---|
556 | |
---|
557 | // Mapping identity segments first |
---|
558 | for (size_t vseg_id = 0; vseg_id < header->globals; vseg_id++) { |
---|
559 | if (vseg[vseg_id].ident == 1) { |
---|
560 | vseg_map(&vseg[vseg_id]); |
---|
561 | } |
---|
562 | } |
---|
563 | |
---|
564 | // Mapping non-identity segments second |
---|
565 | for (size_t vseg_id = 0; vseg_id < header->globals; vseg_id++) { |
---|
566 | if (vseg[vseg_id].ident == 0) { |
---|
567 | vseg_map(&vseg[vseg_id]); |
---|
568 | } |
---|
569 | } |
---|
570 | |
---|
571 | |
---|
572 | |
---|
573 | // loop on virtual spaces to map private vsegs |
---|
574 | for (size_t vspace_id = 0; vspace_id < header->vspaces; vspace_id++) { |
---|
575 | #ifdef MOVER_DEBUG |
---|
576 | std::cout << "\n******* mapping all vsegs of " << vspace[vspace_id].name << " *********\n" << std::endl; |
---|
577 | #endif |
---|
578 | for (size_t vseg_id = vspace[vspace_id].vseg_offset; |
---|
579 | vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs); |
---|
580 | vseg_id++) { |
---|
581 | if (vseg[vseg_id].ident == 1) { |
---|
582 | vseg_map(&vseg[vseg_id]); |
---|
583 | } |
---|
584 | } |
---|
585 | |
---|
586 | for (size_t vseg_id = vspace[vspace_id].vseg_offset; |
---|
587 | vseg_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs); |
---|
588 | vseg_id++) { |
---|
589 | if (vseg[vseg_id].ident == 0) { |
---|
590 | vseg_map(&vseg[vseg_id]); |
---|
591 | } |
---|
592 | } |
---|
593 | } |
---|
594 | } // end buildMap() |
---|
595 | |
---|
596 | |
---|
597 | |
---|
598 | // Local Variables: |
---|
599 | // tab-width: 4 |
---|
600 | // c-basic-offset: 4 |
---|
601 | // c-file-offsets:((innamespace . 0)(inline-open . 0)) |
---|
602 | // indent-tabs-mode: nil |
---|
603 | // End: |
---|
604 | |
---|
605 | // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 |
---|
606 | |
---|