1 //===- ELFObjectReader.cpp ------------------------------------------------===// 2 // 3 // The MCLinker Project 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 #include <mcld/LD/ELFObjectReader.h> 10 11 #include <mcld/IRBuilder.h> 12 #include <mcld/MC/Input.h> 13 #include <mcld/LD/ELFReader.h> 14 #include <mcld/LD/EhFrameReader.h> 15 #include <mcld/LD/EhFrame.h> 16 #include <mcld/Target/GNULDBackend.h> 17 #include <mcld/Support/MsgHandling.h> 18 #include <mcld/Support/MemoryArea.h> 19 #include <mcld/Object/ObjectBuilder.h> 20 21 #include <llvm/Support/ELF.h> 22 #include <llvm/ADT/Twine.h> 23 #include <llvm/ADT/StringRef.h> 24 25 #include <string> 26 #include <cassert> 27 28 using namespace mcld; 29 30 //===----------------------------------------------------------------------===// 31 // ELFObjectReader 32 //===----------------------------------------------------------------------===// 33 /// constructor 34 ELFObjectReader::ELFObjectReader(GNULDBackend& pBackend, 35 IRBuilder& pBuilder, 36 const LinkerConfig& pConfig) 37 : ObjectReader(), 38 m_pELFReader(NULL), 39 m_pEhFrameReader(NULL), 40 m_Builder(pBuilder), 41 m_ReadFlag(ParseEhFrame), 42 m_Backend(pBackend), 43 m_Config(pConfig) { 44 if (pConfig.targets().is32Bits() && pConfig.targets().isLittleEndian()) { 45 m_pELFReader = new ELFReader<32, true>(pBackend); 46 } 47 else if (pConfig.targets().is64Bits() && pConfig.targets().isLittleEndian()) { 48 m_pELFReader = new ELFReader<64, true>(pBackend); 49 } 50 51 m_pEhFrameReader = new EhFrameReader(); 52 } 53 54 /// destructor 55 ELFObjectReader::~ELFObjectReader() 56 { 57 delete m_pELFReader; 58 delete m_pEhFrameReader; 59 } 60 61 /// isMyFormat 62 bool ELFObjectReader::isMyFormat(Input &pInput, bool &pContinue) const 63 { 64 assert(pInput.hasMemArea()); 65 66 // Don't warning about the frequently requests. 67 // MemoryArea has a list of cache to handle this. 68 size_t hdr_size = m_pELFReader->getELFHeaderSize(); 69 if (pInput.memArea()->size() < hdr_size) 70 return false; 71 72 llvm::StringRef region = pInput.memArea()->request(pInput.fileOffset(), 73 hdr_size); 74 75 const char* ELF_hdr = region.begin(); 76 bool result = true; 77 if (!m_pELFReader->isELF(ELF_hdr)) { 78 pContinue = true; 79 result = false; 80 } else if (Input::Object != m_pELFReader->fileType(ELF_hdr)) { 81 pContinue = true; 82 result = false; 83 } else if (!m_pELFReader->isMyEndian(ELF_hdr)) { 84 pContinue = false; 85 result = false; 86 } else if (!m_pELFReader->isMyMachine(ELF_hdr)) { 87 pContinue = false; 88 result = false; 89 } 90 return result; 91 } 92 93 /// readHeader - read section header and create LDSections. 94 bool ELFObjectReader::readHeader(Input& pInput) 95 { 96 assert(pInput.hasMemArea()); 97 98 size_t hdr_size = m_pELFReader->getELFHeaderSize(); 99 if (pInput.memArea()->size() < hdr_size) 100 return false; 101 102 llvm::StringRef region = pInput.memArea()->request(pInput.fileOffset(), 103 hdr_size); 104 const char* ELF_hdr = region.begin(); 105 bool result = m_pELFReader->readSectionHeaders(pInput, ELF_hdr); 106 return result; 107 } 108 109 /// readSections - read all regular sections. 110 bool ELFObjectReader::readSections(Input& pInput) 111 { 112 // handle sections 113 LDContext::sect_iterator section, sectEnd = pInput.context()->sectEnd(); 114 for (section = pInput.context()->sectBegin(); section != sectEnd; ++section) { 115 // ignore the section if the LDSection* in input context is NULL 116 if (NULL == *section) 117 continue; 118 119 switch((*section)->kind()) { 120 /** group sections **/ 121 case LDFileFormat::Group: { 122 assert(NULL != (*section)->getLink()); 123 ResolveInfo* signature = 124 m_pELFReader->readSignature(pInput, 125 *(*section)->getLink(), 126 (*section)->getInfo()); 127 128 bool exist = false; 129 if (0 == signature->nameSize() && 130 ResolveInfo::Section == signature->type()) { 131 // if the signature is a section symbol in input object, we use the 132 // section name as group signature. 133 signatures().insert((*section)->name(), exist); 134 } else { 135 signatures().insert(signature->name(), exist); 136 } 137 138 if (exist) { 139 // if this is not the first time we see this group signature, then 140 // ignore all the members in this group (set Ignore) 141 llvm::StringRef region = pInput.memArea()->request( 142 pInput.fileOffset() + (*section)->offset(), (*section)->size()); 143 const llvm::ELF::Elf32_Word* value = 144 reinterpret_cast<const llvm::ELF::Elf32_Word*>(region.begin()); 145 146 size_t size = region.size() / sizeof(llvm::ELF::Elf32_Word); 147 if (llvm::ELF::GRP_COMDAT == *value) { 148 for (size_t index = 1; index < size; ++index) { 149 pInput.context()->getSection(value[index])->setKind(LDFileFormat::Ignore); 150 } 151 } 152 } 153 ResolveInfo::Destroy(signature); 154 break; 155 } 156 /** linkonce sections **/ 157 case LDFileFormat::LinkOnce: { 158 bool exist = false; 159 // .gnu.linkonce + "." + type + "." + name 160 llvm::StringRef name(llvm::StringRef((*section)->name()).drop_front(14)); 161 signatures().insert(name.split(".").second, exist); 162 if (!exist) { 163 if (name.startswith("wi")) { 164 (*section)->setKind(LDFileFormat::Debug); 165 if (m_Config.options().stripDebug()) 166 (*section)->setKind(LDFileFormat::Ignore); 167 else { 168 SectionData* sd = IRBuilder::CreateSectionData(**section); 169 if (!m_pELFReader->readRegularSection(pInput, *sd)) 170 fatal(diag::err_cannot_read_section) << (*section)->name(); 171 } 172 } else { 173 if (((*section)->flag() & llvm::ELF::SHF_EXECINSTR) != 0) 174 (*section)->setKind(LDFileFormat::TEXT); 175 else 176 (*section)->setKind(LDFileFormat::DATA); 177 SectionData* sd = IRBuilder::CreateSectionData(**section); 178 if (!m_pELFReader->readRegularSection(pInput, *sd)) 179 fatal(diag::err_cannot_read_section) << (*section)->name(); 180 } 181 } else { 182 (*section)->setKind(LDFileFormat::Ignore); 183 } 184 break; 185 } 186 /** relocation sections **/ 187 case LDFileFormat::Relocation: { 188 assert(NULL != (*section)->getLink()); 189 size_t link_index = (*section)->getLink()->index(); 190 LDSection* link_sect = pInput.context()->getSection(link_index); 191 if (NULL == link_sect || LDFileFormat::Ignore == link_sect->kind()) { 192 // Relocation sections of group members should also be part of the 193 // group. Thus, if the associated member sections are ignored, the 194 // related relocations should be also ignored. 195 (*section)->setKind(LDFileFormat::Ignore); 196 } 197 break; 198 } 199 /** normal sections **/ 200 // FIXME: support Version Kind 201 case LDFileFormat::Version: 202 // FIXME: support GCCExceptTable Kind 203 case LDFileFormat::GCCExceptTable: 204 /** Fall through **/ 205 case LDFileFormat::TEXT: 206 case LDFileFormat::DATA: 207 case LDFileFormat::Note: 208 case LDFileFormat::MetaData: { 209 SectionData* sd = IRBuilder::CreateSectionData(**section); 210 if (!m_pELFReader->readRegularSection(pInput, *sd)) 211 fatal(diag::err_cannot_read_section) << (*section)->name(); 212 break; 213 } 214 case LDFileFormat::Debug: { 215 if (m_Config.options().stripDebug()) { 216 (*section)->setKind(LDFileFormat::Ignore); 217 } 218 else { 219 SectionData* sd = IRBuilder::CreateSectionData(**section); 220 if (!m_pELFReader->readRegularSection(pInput, *sd)) { 221 fatal(diag::err_cannot_read_section) << (*section)->name(); 222 } 223 } 224 break; 225 } 226 case LDFileFormat::EhFrame: { 227 EhFrame* eh_frame = IRBuilder::CreateEhFrame(**section); 228 229 // We don't really parse EhFrame if this is a partial linking 230 if ((m_Config.codeGenType() != LinkerConfig::Object) && 231 (m_ReadFlag & ParseEhFrame)) { 232 if (!m_pEhFrameReader->read<32, true>(pInput, *eh_frame)) { 233 // if we failed to parse a .eh_frame, we should not parse the rest 234 // .eh_frame. 235 m_ReadFlag ^= ParseEhFrame; 236 } 237 } 238 else { 239 if (!m_pELFReader->readRegularSection(pInput, 240 *eh_frame->getSectionData())) { 241 fatal(diag::err_cannot_read_section) << (*section)->name(); 242 } 243 } 244 break; 245 } 246 /** target dependent sections **/ 247 case LDFileFormat::Target: { 248 SectionData* sd = IRBuilder::CreateSectionData(**section); 249 if (!m_Backend.readSection(pInput, *sd)) { 250 fatal(diag::err_cannot_read_target_section) << (*section)->name(); 251 } 252 break; 253 } 254 /** BSS sections **/ 255 case LDFileFormat::BSS: { 256 IRBuilder::CreateBSS(**section); 257 break; 258 } 259 // ignore 260 case LDFileFormat::Null: 261 case LDFileFormat::NamePool: 262 case LDFileFormat::Ignore: 263 case LDFileFormat::StackNote: 264 continue; 265 // warning 266 case LDFileFormat::EhFrameHdr: 267 default: { 268 warning(diag::warn_illegal_input_section) << (*section)->name() 269 << pInput.name() 270 << pInput.path(); 271 break; 272 } 273 } 274 } // end of for all sections 275 276 return true; 277 } 278 279 /// readSymbols - read symbols from the input relocatable object. 280 bool ELFObjectReader::readSymbols(Input& pInput) 281 { 282 assert(pInput.hasMemArea()); 283 284 LDSection* symtab_shdr = pInput.context()->getSection(".symtab"); 285 if (NULL == symtab_shdr) { 286 note(diag::note_has_no_symtab) << pInput.name() 287 << pInput.path() 288 << ".symtab"; 289 return true; 290 } 291 292 LDSection* strtab_shdr = symtab_shdr->getLink(); 293 if (NULL == strtab_shdr) { 294 fatal(diag::fatal_cannot_read_strtab) << pInput.name() 295 << pInput.path() 296 << ".symtab"; 297 return false; 298 } 299 300 llvm::StringRef symtab_region = pInput.memArea()->request( 301 pInput.fileOffset() + symtab_shdr->offset(), symtab_shdr->size()); 302 llvm::StringRef strtab_region = pInput.memArea()->request( 303 pInput.fileOffset() + strtab_shdr->offset(), strtab_shdr->size()); 304 const char* strtab = strtab_region.begin(); 305 bool result = m_pELFReader->readSymbols(pInput, 306 m_Builder, 307 symtab_region, 308 strtab); 309 return result; 310 } 311 312 bool ELFObjectReader::readRelocations(Input& pInput) 313 { 314 assert(pInput.hasMemArea()); 315 316 MemoryArea* mem = pInput.memArea(); 317 LDContext::sect_iterator rs, rsEnd = pInput.context()->relocSectEnd(); 318 for (rs = pInput.context()->relocSectBegin(); rs != rsEnd; ++rs) { 319 if (LDFileFormat::Ignore == (*rs)->kind()) 320 continue; 321 322 uint32_t offset = pInput.fileOffset() + (*rs)->offset(); 323 uint32_t size = (*rs)->size(); 324 llvm::StringRef region = mem->request(offset, size); 325 IRBuilder::CreateRelocData(**rs); ///< create relocation data for the header 326 switch ((*rs)->type()) { 327 case llvm::ELF::SHT_RELA: { 328 if (!m_pELFReader->readRela(pInput, **rs, region)) { 329 return false; 330 } 331 break; 332 } 333 case llvm::ELF::SHT_REL: { 334 if (!m_pELFReader->readRel(pInput, **rs, region)) { 335 return false; 336 } 337 break; 338 } 339 default: { ///< should not enter 340 return false; 341 } 342 } // end of switch 343 344 } // end of for all relocation data 345 346 return true; 347 } 348 349
