romimage.cpp

WinCE5.0部分核心源码

      }

      // dll allocations
      for(last = memory_list.end(), mem_itr = memory_list.begin(); mem_itr != memory_list.end(); mem_itr++){
        if(mem_itr->type() == NANDIMAGE_TYPE || mem_itr->type() == RAMIMAGE_TYPE){
          if(config.dll_addr_autosize){
            if(last != memory_list.end()){
              mem_itr->dll_code_bottom = last->dll_code_bottom - (mem_itr->dll_code_orig - mem_itr->dll_code_start) - mem_itr->dll_code_gap;
              mem_itr->dll_data_bottom = last->dll_data_bottom - (mem_itr->dll_data_orig - mem_itr->dll_data_start);

              if(mem_itr->dll_code_bottom < Memory::m_DLL_CODE_BOTTOM_ADDR){
                // don't need to multiply if the entire thing is below.
                if(last->dll_code_bottom == Memory::m_DLL_CODE_BOTTOM_ADDR){
                  mem_itr->dll_data_bottom -= (Memory::m_DLL_CODE_BOTTOM_ADDR - mem_itr->dll_code_bottom);
                }
                else{
                  mem_itr->dll_data_bottom -= (Memory::m_DLL_CODE_BOTTOM_ADDR - mem_itr->dll_code_bottom) + 0x200000;
                  
                  if(debug_show && last != memory_list.end()){
                    printf("Added spacer to region\n");
                  }              
                }
//                printf("%d overflow in dll region\n", (Memory::m_DLL_CODE_BOTTOM_ADDR - mem_itr->dll_code_bottom));
                mem_itr->dll_code_bottom = Memory::m_DLL_CODE_BOTTOM_ADDR;
              }

              // if we're not padded in Module::set_base() --  (I know, this is getting really bad)
              if(!mem_itr->dll_data_split){
                mem_itr->dll_data_bottom -= mem_itr->dll_data_gap;
                
                mem_itr->dll_data_split = mem_itr->dll_data_bottom;
                
                mem_itr->dll_data_bottom -= mem_itr->dll_gap;
              }

              mem_itr->dll_code_bottom &= 0xffff0000;
              mem_itr->dll_data_bottom &= 0xffff0000;
              
              mem_itr->dll_code_orig = last->dll_code_bottom;
              mem_itr->dll_data_orig = last->dll_data_bottom; 
            }
            else{
              mem_itr->dll_code_bottom = mem_itr->dll_code_start - mem_itr->dll_code_gap;
              mem_itr->dll_data_bottom = mem_itr->dll_data_start - mem_itr->dll_data_gap;

              if(mem_itr->dll_code_bottom < Memory::m_DLL_CODE_BOTTOM_ADDR){
                mem_itr->dll_data_bottom -= Memory::m_DLL_CODE_BOTTOM_ADDR - mem_itr->dll_code_bottom;
                mem_itr->dll_code_bottom = Memory::m_DLL_CODE_BOTTOM_ADDR;
              }

              mem_itr->dll_code_bottom &= 0xffff0000;
              mem_itr->dll_data_bottom &= 0xffff0000;
            }

            if(debug_show && last != memory_list.end()){
              printf("Region %s, code %08x, data %08x\n", mem_itr->name().c_str(), mem_itr->dll_code_bottom, mem_itr->dll_data_bottom);
            }              
            last = mem_itr;
          }
        }
      }
    }
  }
//*********************************************//  
// non multixip part
  else{
    if(config.autosize){
      for(mem_itr = memory_list.begin(); mem_itr != memory_list.end(); mem_itr++){
        if(mem_itr->type() == RAM_TYPE)
          ram_section = mem_itr;
  
        if(mem_itr->type() == RAMIMAGE_TYPE || mem_itr->type() == RAM_TYPE){
          start = min(start, mem_itr->address());
          size += mem_itr->length();
        }
      }

      kernel->memory_iterator()->Address::set(start, size);
      ram_section->Address::set(start, size);
    }
    else{
      for(mem_itr = memory_list.begin(); mem_itr != memory_list.end(); mem_itr++){
        if(mem_itr->type() == RAM_TYPE){
          if(kernel->is_arm())
            start = align_64k(Module::s_romhdr.physlast);
          else
            start = kernel->align_page(Module::s_romhdr.physlast);
          
          size = mem_itr->address_end() - start;

          mem_itr->Address::set(start, size);
          printf("RAM AutoSize: RAM Start=%08x RAM Size=%08x\n", start, size);
          
          if(mem_itr->address() > mem_itr->address_end()){
            cerr << "Error: Image is too large for current RAM and RAMIMAGE settings" << endl;
            cerr << "The default end address of RAM was exceeded. To correct this error, set the environment variable IMGRAM64=1." << endl;
            return false;
          }
          
          break;
        }      
      }
    }
  }

  return true;
}

/*****************************************************************************/
bool init_kernel(ModuleList::iterator &kernel, ModuleList &module_list, const MemoryList &memory_list, const Config &config){
  for(MemoryList::const_iterator mem_itr = memory_list.begin(); mem_itr != memory_list.end(); mem_itr++)
    if(mem_itr->type() == RAM_TYPE){
      if(!kernel->init_kernel(config.kernel_fixups, *mem_itr))
        return false;

      bool ret = true;
      for(ModuleList::iterator mod_itr = module_list.begin(); mod_itr != module_list.end(); mod_itr++)
        if(mod_itr->fixup_like_kernel() && !mod_itr->memory_iterator()->is_kernel()){
          cerr << "Error: Module " << mod_itr->name() << " is kernel module but not in kernel region\n";
          ret = false;
        }

      return ret;
    }

  cerr << "Error: No ram section found\n";

  return false;
}

/*****************************************************************************/
bool compute_load_locataions(ModuleList &module_list, const MemoryList &reserve_list, Config &config){
  int offset = 0;
  for(ModuleList::iterator itr = module_list.begin(); itr != module_list.end(); itr++){
    itr->set_load_address(offset);

    offset += itr->get_load_size();

    itr->set_base(reserve_list);

    if(itr->is_dll()){
      static char *suppress = (suppress = getenv("ri_suppress_info")) ? strstr(suppress, "move") : NULL;
      if(!suppress){
        LAST_PASS_PRINT 
          printf("Module %-13s at offset %08x", 
               itr->name().c_str(), 
               itr->memory_iterator()->dll_data_start + File::page_size());
        
        if(itr->is_code_split()) 
          LAST_PASS_PRINT printf(" data, %08x code", itr->memory_iterator()->dll_code_start + File::page_size());

        LAST_PASS_PRINT printf("\n");
      }
    }
  }

  return true;
}

/*****************************************************************************/
bool compact_image(AddressList &hole_list, 
                   CopyList &copy_list, 
                   ModuleList &module_list, 
                   MemoryList &memory_list,
                   FileList &file_list, 
                   const MemoryList &reserve_list, 
                   const Config &config,
                   const MemoryList::iterator &xip_mem){
  DWORD next_avail = xip_mem->address();

  MemoryList::iterator mem_itr;
  ModuleList::iterator mod_itr;
  FileList::iterator file_itr;

  // clean up from previous passes
  hole_list.clear();
  copy_list.clear();

  // put the readony sections in place and find holes
  Module::print_header();
  for(mod_itr = module_list.begin(); mod_itr != module_list.end(); mod_itr++) 
    if(mod_itr->memory_iterator() == xip_mem) 
      FATAL(mod_itr->move_readonly_sections(reserve_list, next_avail, hole_list));

  static char *debug_show = (debug_show = getenv("ri_debug_info")) ? strstr(debug_show, "holes") : NULL;

  // add holes around bin signature in non kernel images
  if(!xip_mem->is_kernel()){
    DWORD temp = xip_mem->address();
    hole_list.push_back(Address(temp, ROM_SIGNATURE_OFFSET));
    hole_list.rbegin()->set_hole();

    // signature size for the sig, then another dword for the toc_offset
    temp += ROM_SIGNATURE_OFFSET + (SIGNATURE_SIZE + 1) * sizeof(DWORD);
    hole_list.push_back(Address(temp, xip_mem->address() + File::page_size() - temp));
    hole_list.rbegin()->set_hole();
  }  

  Address::size_sort(hole_list);

  if(debug_show)
    Address::dump(hole_list, false);

  // add great big hole at the end for everything else, actual size is arbitrary, just has to be BIG!
  // (AND HAS TO WATCH OUT FOR ANY RESERVED SECTIONS IN IT'S WAY)
  // check for reserve sections in the way, may have to be changed for XIP's also?
  if(config.xipchain){
    if(xip_mem->address_end() < next_avail){
      fprintf(stderr, "Error: No room left in memory section.  Image is too large for defined regions.\n");
      fprintf(stderr, "  Region %s from %08x to %08x, has grown to %08x\n",
              xip_mem->name().c_str(),
              xip_mem->address(),
              xip_mem->address_end(),
              next_avail);
            
      return false;
    }

    next_avail = File::align_page(next_avail);
    next_avail = max(next_avail, xip_mem->address() + File::page_size());
    next_avail = min(next_avail, xip_mem->address_end());
    
    if(reserve_list.empty() || reserve_list.begin()->address() >= xip_mem->address_end()){
      // reserve section is so far away that it's of no concern
      // we can just add our default size
      hole_list.push_back(Address(next_avail, xip_mem->address_end() - next_avail));
    }
    else{
      for(MemoryList::const_iterator hitr = reserve_list.begin(); 
          hitr != reserve_list.end() && hitr->address()  < xip_mem->address_end(); 
          hitr++){
        if(hitr->address() >= next_avail){
          hole_list.push_back(Address(next_avail, hitr->address() - next_avail));
          next_avail = Memory::find_next_gap(reserve_list, hitr->address(), 0);
        }
      }
  
      hole_list.push_back(Address(next_avail, xip_mem->address_end() - next_avail));
    }
  }
  else{
    next_avail = File::align_page(next_avail);
    
    if(reserve_list.empty() || reserve_list.begin()->address() >= next_avail + 0x08000000){
      // reserve section is so far away that it's of no concern
      // we can just add our default size
      hole_list.push_back(Address(next_avail, 0x08000000));
    }
    else{
      for(MemoryList::const_iterator hitr = reserve_list.begin(); hitr != reserve_list.end(); hitr++){
        if(hitr->address() >= next_avail){
          hole_list.push_back(Address(next_avail, hitr->address() - next_avail));
          next_avail = Memory::find_next_gap(reserve_list, hitr->address(), 0);
        }
      }
  
      hole_list.push_back(Address(next_avail, 0x08000000));
    }
  }

  for(mod_itr = module_list.begin(); mod_itr != module_list.end(); mod_itr++) if(mod_itr->memory_iterator() == xip_mem) FATAL(mod_itr->move_readwrite_sections(hole_list, copy_list));
  for(mod_itr = module_list.begin(); mod_itr != module_list.end(); mod_itr++) if(mod_itr->memory_iterator() == xip_mem) FATAL(mod_itr->move_eo32_structures(hole_list));

  for(mem_itr = memory_list.begin(); mem_itr != memory_list.end(); mem_itr++){
    if(mem_itr->type() == EXTENSION_TYPE){
      if(mem_itr->extension_location.empty() && xip_mem->is_kernel())
        mem_itr->set_extension_location(xip_mem->name());
      
      if(mem_itr->extension_location == xip_mem->name())
        FATAL(mem_itr->reserve_extension(hole_list));
    }
  }

  if(file_list.size()){
    File::print_header();
    for(file_itr = file_list.begin(); file_itr != file_list.end(); file_itr++) if(file_itr->memory_iterator() == xip_mem) FATAL(file_itr->move_locataion(hole_list));
  }

  Module::print_header();
  for(mod_itr = module_list.begin(); mod_itr != module_list.end(); mod_itr++) if(mod_itr->memory_iterator() == xip_mem) FATAL(mod_itr->move_name(hole_list));
  for(file_itr = file_list.begin(); file_itr != file_list.end(); file_itr++) if(file_itr->memory_iterator()   == xip_mem) FATAL(file_itr->move_name(hole_list));

  Address::dump(hole_list);

  return true;
}