/* Change size of PE header based on word size */
bool
SgAsmPEFileHeader::reallocate()
{
bool reallocated = SgAsmGenericHeader::reallocate();
/* Resize if necessary */
rose_addr_t need = sizeof(PEFileHeader_disk);
if (4==get_word_size()) {
need += sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
need += sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
need += p_rvasize_pairs->get_pairs().size() * sizeof(SgAsmPERVASizePair::RVASizePair_disk);
if (need<get_size()) {
if (is_mapped()) {
ROSE_ASSERT(get_mapped_size()==get_size());
set_mapped_size(need);
}
set_size(need);
reallocated = true;
} else if (need>get_size()) {
get_file()->shift_extend(this, 0, need-get_size(), SgAsmGenericFile::ADDRSP_ALL, SgAsmGenericFile::ELASTIC_HOLE);
reallocated = true;
}
/* Make sure the RVA/Size pairs at the end of the header are consistent with the sections to which they point. Reallocate()
* has already been called recursively for the sections. */
update_rvasize_pairs();
/* Make sure header is consistent with sections. Reallocate() has already been called recursively for the sections.
* Count the number of sections in the table and update the header's e_nsections member. */
if (p_section_table) {
ROSE_ASSERT(p_section_table->get_header()==this);
SgAsmGenericSectionList *all = get_sections();
p_e_nsections = 0;
for (size_t i=0; i<all->get_sections().size(); i++) {
SgAsmPESection *pesec = dynamic_cast<SgAsmPESection*>(all->get_sections()[i]);
if (pesec && pesec->get_section_entry()!=NULL)
p_e_nsections++;
}
rose_addr_t header_size = ALIGN_UP(p_section_table->get_offset() + p_section_table->get_size(),
p_e_file_align>0 ? p_e_file_align : 1);
#if 1
/* The PE Specification regarding e_header_size (known as "SizeOfHeader" on page 14 of "Microsoft Portable Executable
* and Common Object File Format Specification: Revision 8.1 February 15, 2008" is not always followed. We recompute
* it here as being the minimum RVA from all the sections defined in the PE Section Table, but not smaller
* than the value according to the specification. This alternate value is kept if it's already in the parse tree,
* otherwise we use the correct value. (RPM 2008-10-21) */
rose_addr_t min_offset = 0;
for (size_t i=0, nfound=0; i<all->get_sections().size(); i++) {
SgAsmPESection *pesec = dynamic_cast<SgAsmPESection*>(all->get_sections()[i]);
if (pesec && pesec->get_section_entry()!=NULL) {
if (0==nfound++) {
min_offset = pesec->get_offset();
} else {
min_offset = std::min(min_offset, pesec->get_offset() );
}
}
}
rose_addr_t header_size2 = std::max(header_size, min_offset);
if (p_e_header_size==header_size2)
header_size = header_size2;
/* If the original header size was zero then don't change that--leave it at zero. Some tiny executables have a zero
* value here and as a result, since this is near the end of the NT Optional Header, they can truncate the file and
* the loader will fill the optional header with zeros when reading. (RPM 2008-11-11) */
if (p_e_header_size==0)
header_size = 0;
#endif
p_e_header_size = header_size;
}
/* The size of the optional header. If there's a section table then we use its offset to calculate the optional header
* size in order to be compatible with the PE loader. Otherwise use the actual optional header size. */
if (p_section_table) {
ROSE_ASSERT(p_section_table->get_offset() >= get_offset() + sizeof(PEFileHeader_disk));
p_e_nt_hdr_size = p_section_table->get_offset() - (get_offset() + sizeof(PEFileHeader_disk));
} else if (4==get_word_size()) {
p_e_nt_hdr_size = sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
p_e_nt_hdr_size = sizeof(PE64OptHeader_disk);
} else {
throw FormatError("invalid PE word size");
}
/* Update COFF symbol table related data members in the file header */
if (get_coff_symtab()) {
ROSE_ASSERT(get_coff_symtab()->get_header()==this);
set_e_coff_symtab(get_coff_symtab()->get_offset());
set_e_coff_nsyms(get_coff_symtab()->get_nslots());
}
/* Update some additional header fields */
set_e_num_rvasize_pairs(get_rvasize_pairs()->get_pairs().size());
set_e_opt_magic(4==get_word_size() ? 0x010b : 0x020b);
set_e_lmajor((get_exec_format()->get_version() >> 16) & 0xffff);
set_e_lminor(get_exec_format()->get_version() & 0xffff);
/* Adjust the COFF Header's e_nt_hdr_size to accommodate the NT Optional Header in such a way that EXEs from tinype.com
* don't change (i.e., don't increase e_nt_hdr_size if the bytes beyond it are zero anyway, and if they aren't then adjust
* it as little as possible. The RVA/Size pairs are considered to be part of the NT Optional Header. */
size_t oh_size = p_rvasize_pairs->get_pairs().size() * sizeof(SgAsmPERVASizePair::RVASizePair_disk);
size_t rvasize_offset; /*offset with respect to "oh" buffer allocated below*/
if (4==get_word_size()) {
oh_size += sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
oh_size += sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
unsigned char *oh = new unsigned char[oh_size];
if (4==get_word_size()) {
encode((PE32OptHeader_disk*)oh);
rvasize_offset = sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
encode((PE64OptHeader_disk*)oh);
rvasize_offset = sizeof(PE64OptHeader_disk);
} else {
delete[] oh;
throw FormatError("unsupported PE word size");
}
while (oh_size>p_e_nt_hdr_size) {
if (0!=oh[oh_size-1]) break;
--oh_size;
}
set_e_nt_hdr_size(oh_size);
return reallocated;
}
//Execute
void cl_acc::execute()
{
//Local variables
PINOUT tmp_pinout;
uint32_t addr;
uint32_t burst;
uint32_t data;
uint32_t bw;
bool wr;
uint32_t size;
int essai=0;
//Initializations
sl_rdy.write(false);
//Main thread
while(1)
{
//Wait for request
if(!sl_req.read())
wait(sl_req.posedge_event());
//Get request
tmp_pinout = slave_port.read();
addr = tmp_pinout.address; //Address
burst = tmp_pinout.burst; //Size of burst
bw = tmp_pinout.bw; //Size of data
wr = tmp_pinout.rw; //Read/write cmd
size = get_word_size ( bw );
cout<<"ACCELERATOR Execute function call"<<endl;
//It is a READ request
if (!wr)
{
if (addr==ACC_READY_ADDR)
{
//Debug
//cout << "ACCELERATOR Wait for the end of the processing at "<<sc_time_stamp()<<endl;
//Wait the end of the processing
if (status == CL_ACC_INACTIVE ) tmp_pinout.data = 1;
else tmp_pinout.data = 0;
//End of processing
//tmp_pinout.data = 1;
//Write answer
slave_port.write ( tmp_pinout );
//Handshaking
sl_rdy.write ( true );
wait();
sl_rdy.write ( false );
wait();
}
else
{
//Change status
status = CL_ACC_READ;
//Debug
//cout << "ACCELERATOR Read at the address "<<hex<<addr<< " at "<<sc_time_stamp()<<endl;
//Return the requested data
for (int i = 0; i < burst; i ++)
{
wait();
sl_rdy.write ( false );
data = this->Read ( addr, bw );
//Wait 1 cycle between burst beat
wait();
//Increment the address for the next beat
addr += size;
tmp_pinout.data = data;
slave_port.write ( tmp_pinout );
sl_rdy.write ( true );
}
wait();
sl_rdy.write ( false );
wait();
//Change status
status = CL_ACC_INACTIVE;
}
}
//It is a write
else
{
//Get the data to write
data = tmp_pinout.data;
//Control part
if (addr==ACC_START_ADDR)
{
if (data==1)
{
status = CL_ACC_START;
//Send active signal
start_processing.notify();
//Debug
cout<<"ACCELERATOR: Start processing"<<endl;
}
else
{
status = CL_ACC_INACTIVE;
//Debug
cout<<"ACCELERATOR: Stop processing"<<endl;
}
//Handshaking
sl_rdy.write ( true );
wait();
sl_rdy.write ( false );
wait();
}
else
{
//Change status
status = CL_ACC_WRITE;
//Debug
//cout << "ACCELERATOR Write at the address "<<hex<<addr<<" the value "<<data<< " at "<<sc_time_stamp()<<endl;
//Write the data in the request
for (int i = 0; i < burst; i ++)
{
wait();
sl_rdy.write ( false );
this->Write ( addr, data, bw );
// Wait 1 cycle between burst beat
wait();
// Increment the address for the next beat
addr += size;
sl_rdy.write ( true );
}
wait();
sl_rdy.write ( false );
wait();
//Change status
status = CL_ACC_INACTIVE;
}
}
}
}
/** Update prior to unparsing */
bool
SgAsmElfFileHeader::reallocate()
{
/* Reallocate superclass. This also calls reallocate() for all the sections associated with this ELF File Header. */
bool reallocated = SgAsmGenericHeader::reallocate();
/* Resize header based on current word size */
rose_addr_t need;
if (4==get_word_size()) {
need = sizeof(Elf32FileHeader_disk);
} else if (8==get_word_size()) {
need = sizeof(Elf64FileHeader_disk);
} else {
throw FormatError("unsupported ELF word size");
}
if (need < get_size()) {
if (is_mapped()) {
ROSE_ASSERT(get_mapped_size()==get_size());
set_mapped_size(need);
}
set_size(need);
reallocated = true;
} else if (need > get_size()) {
get_file()->shift_extend(this, 0, need-get_size(), SgAsmGenericFile::ADDRSP_ALL, SgAsmGenericFile::ELASTIC_HOLE);
reallocated = true;
}
/* Update ELF-specific file class data member from generic data. */
switch(get_word_size()) {
case 4:
p_e_ident_file_class = 1;
break;
case 8:
p_e_ident_file_class = 2;
break;
default:
ROSE_ASSERT(!"invalid word size");
break;
}
/* Byte order. According to the spec, valid values are 1 (little-endian) and 2 (big-endian). However, we've seen cases
* where a value of zero is used to indicate "native" order (loader assumes words are in the order of the machine on which
* the loader is running, and the ROSE ELF parser determines the order by looking at other fields in the header). Any
* original value other than 1 or 2 will be written to the new output; otherwise we choose 1 or 2 based on the currently
* defined byte order. */
if (p_e_ident_data_encoding==1 || p_e_ident_data_encoding==2) {
p_e_ident_data_encoding = ByteOrder::ORDER_LSB==get_sex() ? 1 : 2;
}
/* Update ELF-specific file type from generic data. */
switch (p_exec_format->get_purpose()) {
case PURPOSE_UNSPECIFIED:
case PURPOSE_PROC_SPECIFIC:
case PURPOSE_OS_SPECIFIC:
case PURPOSE_OTHER:
/* keep as is */
break;
case PURPOSE_LIBRARY:
if (p_e_type==1 || p_e_type==3) {
/* keep as is */
} else {
p_e_type = 1;
}
break;
case PURPOSE_EXECUTABLE:
p_e_type = 2;
break;
case PURPOSE_CORE_DUMP:
p_e_type = 4;
}
/* Update ELF machine type. */
p_e_machine = isa_to_machine(get_isa());
/* The ELF header stores its own size */
p_e_ehsize = get_size();
return reallocated;
}
/* Write the PE file header back to disk and all that it references */
void
SgAsmPEFileHeader::unparse(std::ostream &f) const
{
/* Write unreferenced areas back to the file before anything else. */
unparse_holes(f);
/* Write sections in the order of specialization, from least specialized to most specialized. This gives more specialized
* sections a chance to overwrite the less specialized sections. */
const SgAsmGenericSectionPtrList §ions = get_sections()->get_sections();
for (SgAsmGenericSectionPtrList::const_iterator si=sections.begin(); si!=sections.end(); ++si) {
if (V_SgAsmGenericSection==(*si)->variantT())
(*si)->unparse(f);
}
for (SgAsmGenericSectionPtrList::const_iterator si=sections.begin(); si!=sections.end(); ++si) {
if (V_SgAsmPESection==(*si)->variantT())
(*si)->unparse(f);
}
for (SgAsmGenericSectionPtrList::const_iterator si=sections.begin(); si!=sections.end(); ++si) {
if (V_SgAsmGenericSection!=(*si)->variantT() && V_SgAsmPESection!=(*si)->variantT())
(*si)->unparse(f);
}
/* Encode the "NT Optional Header" before the COFF Header since the latter depends on the former. Adjust the COFF Header's
* e_nt_hdr_size to accommodate the NT Optional Header in such a way that EXEs from tinype.com don't change (i.e., don't
* increase e_nt_hdr_size if the bytes beyond it are zero anyway, and if they aren't then adjust it as little as possible.
* The RVA/Size pairs are considered to be part of the NT Optional Header. */
size_t oh_size = p_rvasize_pairs->get_pairs().size() * sizeof(SgAsmPERVASizePair::RVASizePair_disk);
size_t rvasize_offset; /*offset with respect to "oh" buffer allocated below*/
if (4==get_word_size()) {
oh_size += sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
oh_size += sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
unsigned char *oh = new unsigned char[oh_size];
if (4==get_word_size()) {
encode((PE32OptHeader_disk*)oh);
rvasize_offset = sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
encode((PE64OptHeader_disk*)oh);
rvasize_offset = sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
for (size_t i=0; i<p_rvasize_pairs->get_pairs().size(); i++, rvasize_offset+=sizeof(SgAsmPERVASizePair::RVASizePair_disk)) {
SgAsmPERVASizePair::RVASizePair_disk *rvasize_disk = (SgAsmPERVASizePair::RVASizePair_disk*)(oh+rvasize_offset);
p_rvasize_pairs->get_pairs()[i]->encode(rvasize_disk);
}
while (oh_size>p_e_nt_hdr_size) {
if (0!=oh[oh_size-1]) break;
--oh_size;
}
ROSE_ASSERT(p_e_nt_hdr_size==oh_size); /*set in reallocate()*/
/* Write the fixed-length COFF Header */
PEFileHeader_disk fh;
encode(&fh);
rose_addr_t spos = write(f, 0, sizeof fh, &fh);
/* Write the following "NT Optional Header" */
spos = write(f, spos, oh_size, oh);
}
