uint32_t RawSection::read(BinaryInputFile* b){
b->setInPointer(rawDataPtr);
setFileOffset(b->currentOffset());
verify();
return sizeInBytes;
}
uint32_t ProgramHeader64::read(BinaryInputFile* binaryInputFile){
setFileOffset(binaryInputFile->currentOffset());
if(!binaryInputFile->copyBytesIterate(&entry,Size__64_bit_Program_Header)){
PRINT_ERROR("Program header (64) can not be read");
}
return Size__64_bit_Program_Header;
}
off_t SkPDFCatalog::setSubstituteResourcesOffsets(off_t fileOffset,
bool firstPage) {
SkTDArray<SkPDFObject*>* targetList = getSubstituteList(firstPage);
off_t offsetSum = fileOffset;
for (int i = 0; i < targetList->count(); ++i) {
offsetSum += setFileOffset((*targetList)[i], (size_t) offsetSum);
}
return offsetSum - fileOffset;
}
int DbFileOp::restoreBlock(IDBDataFile* pFile, const unsigned char* writeBuf, uint64_t fbo)
{
if (m_chunkManager)
return m_chunkManager->restoreBlock(pFile, writeBuf, fbo);
if (setFileOffset(pFile, fbo*BYTE_PER_BLOCK, SEEK_SET) != NO_ERROR)
return -1;
return pFile->write(writeBuf, BYTE_PER_BLOCK);
}
uint32_t Symbol64::read(BinaryInputFile* binaryInputFile){
binaryInputFile->setInPointer(symbolPtr);
setFileOffset(binaryInputFile->currentOffset());
if(!binaryInputFile->copyBytesIterate(&entry,Size__64_bit_Symbol)){
PRINT_ERROR("Symbol (64) can not be read");
}
verify(Size__64_bit_Symbol);
return sizeInBytes;
}
int DbFileOp::readDbBlocks(IDBDataFile* pFile,
unsigned char* readBuf,
uint64_t fbo,
size_t n)
{
if (m_chunkManager) {
return m_chunkManager->readBlocks(pFile, readBuf, fbo, n);
}
if (setFileOffset(pFile, fbo*BYTE_PER_BLOCK, SEEK_SET) != NO_ERROR)
return -1;
return pFile->read(readBuf, BYTE_PER_BLOCK * n) / BYTE_PER_BLOCK;
}
uint32_t SectionHeader64::read(BinaryInputFile* binaryInputFile){
setFileOffset(binaryInputFile->currentOffset());
if(!binaryInputFile->copyBytesIterate(&entry,Size__64_bit_Section_Header)){
PRINT_ERROR("Section header (64) can not be read");
}
setSectionType();
verify();
return Size__64_bit_Section_Header;
}
// Copy constructor for the user log header
UserLogHeader::UserLogHeader( const UserLogHeader &other )
{
setId( other.getId() );
setSequence( other.getSequence() );
setCtime( other.getCtime() );
setSize( other.getSize() );
setNumEvents( other.getNumEvents() );
setFileOffset( other.getFileOffset() );
setEventOffset( other.getEventOffset() );
setMaxRotation( other.getMaxRotation() );
setCreatorName( other.getCreatorName() );
m_valid = other.IsValid( );
}
// just don't have a good solution to consolidate with above functions
// Note: This is used with absolute FBO, no lbid involved
int DbFileOp::writeDBFileFbo(IDBDataFile* pFile, const unsigned char* writeBuf,
const uint64_t fbo, const int numOfBlock )
{
long long fboOffset = 0;
fboOffset = (fbo)*(long)BYTE_PER_BLOCK;
RETURN_ON_ERROR( setFileOffset( pFile, fboOffset ) );
for( int i = 0; i < numOfBlock; i++ ) {
Stats::incIoBlockWrite();
RETURN_ON_ERROR( writeFile( pFile, writeBuf, BYTE_PER_BLOCK ) );
}
return NO_ERROR;
}
/***********************************************************
* DESCRIPTION:
* Read a block from a file at specified location
* PARAMETERS:
* pFile - file handle
* readBuf - read buffer
* fbo - file block offset
* RETURN:
* NO_ERROR if success
* other number if something wrong
***********************************************************/
int DbFileOp::readDBFile( IDBDataFile* pFile,
unsigned char* readBuf,
const uint64_t lbid,
const bool isFbo )
{
long long fboOffset = 0;
if( !isFbo ) {
RETURN_ON_ERROR( setFileOffsetBlock( pFile, lbid ) );
}
else {
fboOffset = (lbid)*(long)BYTE_PER_BLOCK;
RETURN_ON_ERROR( setFileOffset( pFile, fboOffset ) );
}
return readFile( pFile, readBuf, BYTE_PER_BLOCK );
}
uint32_t SymbolTable::read(BinaryInputFile* binaryInputFile){
binaryInputFile->setInPointer(getFilePointer());
setFileOffset(binaryInputFile->currentOffset());
uint32_t totalBytesRead = 0;
uint32_t numberOfSymbols = sizeInBytes / symbolSize;
for (uint32_t i = 0; i < numberOfSymbols; i++){
if (elfFile->is64Bit()){
symbols.append(new Symbol64(this, getFilePointer() + (i * Size__64_bit_Symbol), i));
} else {
symbols.append(new Symbol32(this, getFilePointer() + (i * Size__32_bit_Symbol), i));
}
totalBytesRead += symbols[i]->read(binaryInputFile);
}
ASSERT(sizeInBytes == totalBytesRead && "size read from file does not match theorietical size of Symbol Table");
return sizeInBytes;
}
uint32_t LineInfoTable::read(BinaryInputFile* binaryInputFile){
binaryInputFile->setInPointer(rawDataPtr);
setFileOffset(binaryInputFile->currentOffset());
uint32_t currByte = 0;
uint32_t firstWord = 0;
if (!binaryInputFile->copyBytesIterate(&firstWord,sizeof(uint32_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint32_t);
if (firstWord >= DWARF2_FIRSTBYTE_LO){
if (firstWord == DWARF2_FIRSTBYTE_64BIT_FORMAT){
format = DebugFormat_DWARF2_64bit;
} else {
PRINT_ERROR("The first word %d of this debug section is not an understood DWARF2 format", firstWord);
}
} else {
format = DebugFormat_DWARF2_32bit;
}
ASSERT(format && "The format of this debug section is unknown");
PRINT_DEBUG_LINEINFO("The format of the debug section is %d", format);
// get the line info header
if (format == DebugFormat_DWARF2_64bit){
if(!binaryInputFile->copyBytesIterate(&entry.li_length,sizeof(uint64_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint64_t);
} else {
entry.li_length = firstWord;
}
if(!binaryInputFile->copyBytesIterate(&entry.li_version,sizeof(uint16_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint16_t);
if (format == DebugFormat_DWARF2_64bit){
if(!binaryInputFile->copyBytesIterate(&entry.li_prologue_length,sizeof(uint64_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint64_t);
} else {
if(!binaryInputFile->copyBytesIterate(&firstWord,sizeof(uint32_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint32_t);
entry.li_prologue_length = firstWord;
}
if(!binaryInputFile->copyBytesIterate(&entry.li_min_insn_length,sizeof(uint8_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint8_t);
if(!binaryInputFile->copyBytesIterate(&entry.li_default_is_stmt,sizeof(uint8_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint8_t);
if(!binaryInputFile->copyBytesIterate(&entry.li_line_base,sizeof(uint8_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint8_t);
if(!binaryInputFile->copyBytesIterate(&entry.li_line_range,sizeof(uint8_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint8_t);
if(!binaryInputFile->copyBytesIterate(&entry.li_opcode_base,sizeof(uint8_t))){
PRINT_ERROR("Line info section header cannot be read");
}
currByte += sizeof(uint8_t);
sizeInBytes = GET(li_length) + sizeof(uint32_t);
if (format == DebugFormat_DWARF2_64bit){
sizeInBytes += 8;
}
DEBUG_LINEINFO(dwarfLineInfoSection->printBytes(0,0,0);)
