include/impl/ELFObject.hxx - platform/frameworks/compile/linkloader - Git at Google

 /*
  * Copyright 2011, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef ELF_OBJECT_HXX
 #define ELF_OBJECT_HXX

 #include "ELFHeader.h"
 #include "ELFReloc.h"
 #include "ELFSection.h"
 #include "ELFSectionHeaderTable.h"
 #include "StubLayout.h"
 #include "ELF.h"

 #include <llvm/ADT/SmallVector.h>

 #include "utils/rsl_assert.h"

 template <unsigned Bitwidth>
 template <typename Archiver>
 inline ELFObject<Bitwidth> *
 ELFObject<Bitwidth>::read(Archiver &AR) {
   llvm::OwningPtr<ELFObjectTy> object(new ELFObjectTy());

   // Read header
   object->header.reset(ELFHeaderTy::read(AR));
   if (!object->header) {
     return 0;
   }

   // Read section table
   object->shtab.reset(ELFSectionHeaderTableTy::read(AR, object.get()));
   if (!object->shtab) {
     return 0;
   }

   // Read each section
   llvm::SmallVector<size_t, 4> progbits_ndx;
   for (size_t i = 0; i < object->header->getSectionHeaderNum(); ++i) {
     if ((*object->shtab)[i]->getType() == SHT_PROGBITS) {
       object->stab.push_back(NULL);
       progbits_ndx.push_back(i);
     } else {
       llvm::OwningPtr<ELFSectionTy> sec(
         ELFSectionTy::read(AR, object.get(), (*object->shtab)[i]));
       object->stab.push_back(sec.take());
     }
   }

   object->shtab->buildNameMap();
   ELFSectionSymTabTy *symtab =
     static_cast<ELFSectionSymTabTy *>(object->getSectionByName(".symtab"));
   rsl_assert(symtab && "Symtab is required.");
   symtab->buildNameMap();

   for (size_t i = 0; i < progbits_ndx.size(); ++i) {
     size_t index = progbits_ndx[i];

     llvm::OwningPtr<ELFSectionTy> sec(
       ELFSectionTy::read(AR, object.get(), (*object->shtab)[index]));
     object->stab[index] = sec.take();
   }

   return object.take();
 }

 template <unsigned Bitwidth>
 inline char const *ELFObject<Bitwidth>::getSectionName(size_t i) const {
   ELFSectionTy const *sec = stab[header->getStringSectionIndex()];

   if (sec) {
     ELFSectionStrTabTy const &st =
       static_cast<ELFSectionStrTabTy const &>(*sec);
     return st[i];
   }

   return NULL;
 }

 template <unsigned Bitwidth>
 inline ELFSection<Bitwidth> const *
 ELFObject<Bitwidth>::getSectionByIndex(size_t i) const {
   return stab[i];
 }

 template <unsigned Bitwidth>
 inline ELFSection<Bitwidth> *
 ELFObject<Bitwidth>::getSectionByIndex(size_t i) {
   return stab[i];
 }

 template <unsigned Bitwidth>
 inline ELFSection<Bitwidth> const *
 ELFObject<Bitwidth>::getSectionByName(std::string const &str) const {
   size_t idx = getSectionHeaderTable()->getByName(str)->getIndex();
   return stab[idx];
 }

 template <unsigned Bitwidth>
 inline ELFSection<Bitwidth> *
 ELFObject<Bitwidth>::getSectionByName(std::string const &str) {
   ELFObjectTy const *const_this = this;
   ELFSectionTy const *sptr = const_this->getSectionByName(str);
   // Const cast for the same API's const and non-const versions.
   return const_cast<ELFSectionTy *>(sptr);
 }


 template <unsigned Bitwidth>
 inline void ELFObject<Bitwidth>::
 relocateARM(void *(*find_sym)(void *context, char const *name),
             void *context,
             ELFSectionRelTableTy *reltab,
             ELFSectionProgBitsTy *text) {
   // FIXME: Should be implement in independent files.
   rsl_assert(Bitwidth == 32 && "ARM only have 32 bits.");

   ELFSectionSymTabTy *symtab =
     static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
   rsl_assert(symtab && "Symtab is required.");

   for (size_t i = 0; i < reltab->size(); ++i) {
     // FIXME: Can not implement here, use Fixup!
     ELFRelocTy *rel = (*reltab)[i];
     ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];

     // FIXME: May be not uint32_t *.
     typedef int32_t Inst_t;
     Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
     Inst_t P = (Inst_t)(int64_t)inst;
     Inst_t A = 0;
     Inst_t S = (Inst_t)(int64_t)sym->getAddress();

     switch (rel->getType()) {
     default:
       rsl_assert(0 && "Not implemented relocation type.");
       break;

     case R_ARM_ABS32:
       {
         A = *inst;
         *inst = (S+A);
       }
       break;

       // FIXME: Predefine relocation codes.
     case R_ARM_CALL:
       {
 #define SIGN_EXTEND(x, l) (((x)^(1<<((l)-1)))-(1<<(l-1)))
         A = (Inst_t)(int64_t)SIGN_EXTEND(*inst & 0xFFFFFF, 24);
 #undef SIGN_EXTEND

         switch (sym->getType()) {
         default:
           rsl_assert(0 && "Wrong type for R_ARM_CALL relocation.");
           abort();
           break;

         case STT_FUNC:
           if (S == 0) {
             rsl_assert(0 && "We should get function address at previous "
                    "sym->getAddress() function call.");
             abort();
           }
           break;

         case STT_NOTYPE:
           if (S == 0) {
             void *ext_func = find_sym(context, sym->getName());
 #ifdef SUPPORT_NEAR_JUMP_EVEN_IF_BLc2BLX_NEEDED
             S = (Inst_t)(uintptr_t)ext_func;
             sym->setAddress(ext_func);

             uint32_t result = (S >> 2) - (P >> 2) + A;
             if (result > 0x007fffff && result < 0xff800000) {
 #endif
 #ifndef __arm__
               // We have not implement function stub in this runtime env
               rsl_assert(0 && "Target address is far from call instruction");
               abort();
 #else
               void *stub = text->getStubLayout()->allocateStub(ext_func);
               if (!stub) {
                 llvm::errs() << "unable to allocate stub." << "\n";
                 exit(EXIT_FAILURE);
               }

               //out() << "stub: for " << ext_func << " at " << stub << "\n";
               sym->setAddress(stub);
               S = (uint32_t)stub;
 #endif
 #ifdef SUPPORT_NEAR_JUMP_EVEN_IF_BLc2BLX_NEEDED
             }
 #endif
           }
           break;
         }

         uint32_t result = (S >> 2) - (P >> 2) + A;

         if (result > 0x007fffff && result < 0xff800000) {
           rsl_assert(0 && "Stub is still too far");
           abort();
         }

         *inst = ((result) & 0x00FFFFFF) | (*inst & 0xFF000000);
       }
       break;
     case R_ARM_MOVT_ABS:
     case R_ARM_MOVW_ABS_NC:
       {
         if (S==0 && sym->getType() == STT_NOTYPE)
         {
           void *ext_sym = find_sym(context, sym->getName());
           S = (Inst_t)(uintptr_t)ext_sym;
           sym->setAddress(ext_sym);
         }
         if (rel->getType() == R_ARM_MOVT_ABS) {
           S >>= 16;
         }

         // No need sign extend.
         A = ((*inst & 0xF0000) >> 4) | (*inst & 0xFFF);
         uint32_t result = (S+A);
         *inst = (((result) & 0xF000) << 4) |
           ((result) & 0xFFF) |
           (*inst & 0xFFF0F000);
       }
       break;
     }
     //llvm::errs() << "S:     " << (void *)S << '\n';
     //llvm::errs() << "A:     " << (void *)A << '\n';
     //llvm::errs() << "P:     " << (void *)P << '\n';
     //llvm::errs() << "S+A:   " << (void *)(S+A) << '\n';
     //llvm::errs() << "S+A-P: " << (void *)(S+A-P) << '\n';
   }
 }

 template <unsigned Bitwidth>
 inline void ELFObject<Bitwidth>::
 relocateX86_64(void *(*find_sym)(void *context, char const *name),
                void *context,
                ELFSectionRelTableTy *reltab,
                ELFSectionProgBitsTy *text) {
   rsl_assert(Bitwidth == 64 && "Only support X86_64.");

   ELFSectionSymTabTy *symtab =
     static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
   rsl_assert(symtab && "Symtab is required.");

   for (size_t i = 0; i < reltab->size(); ++i) {
     // FIXME: Can not implement here, use Fixup!
     ELFRelocTy *rel = (*reltab)[i];
     ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];

     //typedef uint64_t Inst_t;
     typedef int32_t Inst_t;
     Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
     Inst_t P = (Inst_t)(int64_t)inst;
     Inst_t A = (Inst_t)(int64_t)rel->getAddend();
     Inst_t S = (Inst_t)(int64_t)sym->getAddress();

     if (S == 0) {
       S = (Inst_t)(int64_t)find_sym(context, sym->getName());
       sym->setAddress((void *)S);
     }

     switch (rel->getType()) {
       default:
         rsl_assert(0 && "Not implemented relocation type.");
         break;

       // FIXME: XXX: R_X86_64_64 is 64 bit, there is a big problem here.
       case 1: // R_X86_64_64
         *inst = (S+A);
         break;

       case 2: // R_X86_64_PC32
         *inst = (S+A-P);
         break;

       case 10: // R_X86_64_32
       case 11: // R_X86_64_32S
         *inst = (S+A);
         break;
     }
   }
 }

 template <unsigned Bitwidth>
 inline void ELFObject<Bitwidth>::
 relocateX86_32(void *(*find_sym)(void *context, char const *name),
                void *context,
                ELFSectionRelTableTy *reltab,
                ELFSectionProgBitsTy *text) {
   rsl_assert(Bitwidth == 32 && "Only support X86.");

   ELFSectionSymTabTy *symtab =
     static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
   rsl_assert(symtab && "Symtab is required.");

   for (size_t i = 0; i < reltab->size(); ++i) {
     // FIXME: Can not implement here, use Fixup!
     ELFRelocTy *rel = (*reltab)[i];
     ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];

     //typedef uint64_t Inst_t;
     typedef int32_t Inst_t;
     Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
     Inst_t P = (Inst_t)(uintptr_t)inst;
     Inst_t A = (Inst_t)(uintptr_t)*inst;
     Inst_t S = (Inst_t)(uintptr_t)sym->getAddress();

     if (S == 0) {
       S = (Inst_t)(uintptr_t)find_sym(context, sym->getName());
       sym->setAddress((void *)S);
     }

     switch (rel->getType()) {
     default:
       rsl_assert(0 && "Not implemented relocation type.");
       break;

     case R_386_PC32:
       *inst = (S+A-P);
       break;

     case R_386_32:
       *inst = (S+A);
       break;
     }
   }
 }

 // TODO: Refactor all relocations.
 template <unsigned Bitwidth>
 inline void ELFObject<Bitwidth>::
 relocate(void *(*find_sym)(void *context, char const *name), void *context) {
   // Init SHNCommonDataSize.
   // Need refactoring
   size_t SHNCommonDataSize = 0;

   ELFSectionSymTabTy *symtab =
     static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
   rsl_assert(symtab && "Symtab is required.");

   for (size_t i = 0; i < symtab->size(); ++i) {
     ELFSymbolTy *sym = (*symtab)[i];

     if (sym->getType() != STT_OBJECT) {
       continue;
     }

     size_t idx = (size_t)sym->getSectionIndex();
     switch (idx) {
     default:
       if ((*shtab)[idx]->getType() == SHT_NOBITS) {
         // FIXME(logan): This is a workaround for .lcomm directives
         // bug of LLVM ARM MC code generator.  Remove this when the
         // LLVM bug is fixed.

         size_t align = 16;
         SHNCommonDataSize += (size_t)sym->getSize() + align;
       }
       break;

     case SHN_COMMON:
       {
         size_t align = (size_t)sym->getValue();
         SHNCommonDataSize += (size_t)sym->getSize() + align;
       }
       break;

     case SHN_ABS:
     case SHN_UNDEF:
     case SHN_XINDEX:
       break;
     }
   }
   if (!initSHNCommonDataSize(SHNCommonDataSize)) {
     rsl_assert("Allocate memory for common variable fail!");
   }

   for (size_t i = 0; i < stab.size(); ++i) {
     ELFSectionHeaderTy *sh = (*shtab)[i];
     if (sh->getType() != SHT_REL && sh->getType() != SHT_RELA) {
       continue;
     }
     ELFSectionRelTableTy *reltab =
       static_cast<ELFSectionRelTableTy *>(stab[i]);
     rsl_assert(reltab && "Relocation section can't be NULL.");

     const char *reltab_name = sh->getName();
     const char *need_rel_name;
     if (sh->getType() == SHT_REL) {
       need_rel_name = reltab_name + 4;
       // ".rel.xxxx"
       //      ^ start from here.
     } else {
       need_rel_name = reltab_name + 5;
     }

     ELFSectionProgBitsTy *need_rel =
       static_cast<ELFSectionProgBitsTy *>(getSectionByName(need_rel_name));
     rsl_assert(need_rel && "Need be relocated section can't be NULL.");

     switch (getHeader()->getMachine()) {
       case EM_ARM:
         relocateARM(find_sym, context, reltab, need_rel);
         break;
       case EM_386:
         relocateX86_32(find_sym, context, reltab, need_rel);
         break;
       case EM_X86_64:
         relocateX86_64(find_sym, context, reltab, need_rel);
         break;

       default:
         rsl_assert(0 && "Only support ARM, X86, and X86_64 relocation.");
         break;
     }
   }

   for (size_t i = 0; i < stab.size(); ++i) {
     ELFSectionHeaderTy *sh = (*shtab)[i];
     if (sh->getType() == SHT_PROGBITS || sh->getType() == SHT_NOBITS) {
       if (stab[i]) {
         static_cast<ELFSectionBitsTy *>(stab[i])->protect();
       }
     }
   }
 }

 template <unsigned Bitwidth>
 inline void ELFObject<Bitwidth>::print() const {
   header->print();
   shtab->print();

   for (size_t i = 0; i < stab.size(); ++i) {
     ELFSectionTy *sec = stab[i];
     if (sec) {
       sec->print();
     }
   }
 }

 #endif // ELF_OBJECT_HXX
	/*
	* Copyright 2011, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef ELF_OBJECT_HXX
	#define ELF_OBJECT_HXX

	#include "ELFHeader.h"
	#include "ELFReloc.h"
	#include "ELFSection.h"
	#include "ELFSectionHeaderTable.h"
	#include "StubLayout.h"
	#include "ELF.h"

	#include <llvm/ADT/SmallVector.h>

	#include "utils/rsl_assert.h"

	template <unsigned Bitwidth>
	template <typename Archiver>
	inline ELFObject<Bitwidth> *
	ELFObject<Bitwidth>::read(Archiver &AR) {
	llvm::OwningPtr<ELFObjectTy> object(new ELFObjectTy());

	// Read header
	object->header.reset(ELFHeaderTy::read(AR));
	if (!object->header) {
	return 0;
	}

	// Read section table
	object->shtab.reset(ELFSectionHeaderTableTy::read(AR, object.get()));
	if (!object->shtab) {
	return 0;
	}

	// Read each section
	llvm::SmallVector<size_t, 4> progbits_ndx;
	for (size_t i = 0; i < object->header->getSectionHeaderNum(); ++i) {
	if ((*object->shtab)[i]->getType() == SHT_PROGBITS) {
	object->stab.push_back(NULL);
	progbits_ndx.push_back(i);
	} else {
	llvm::OwningPtr<ELFSectionTy> sec(
	ELFSectionTy::read(AR, object.get(), (*object->shtab)[i]));
	object->stab.push_back(sec.take());
	}
	}

	object->shtab->buildNameMap();
	ELFSectionSymTabTy *symtab =
	static_cast<ELFSectionSymTabTy *>(object->getSectionByName(".symtab"));
	rsl_assert(symtab && "Symtab is required.");
	symtab->buildNameMap();

	for (size_t i = 0; i < progbits_ndx.size(); ++i) {
	size_t index = progbits_ndx[i];

	llvm::OwningPtr<ELFSectionTy> sec(
	ELFSectionTy::read(AR, object.get(), (*object->shtab)[index]));
	object->stab[index] = sec.take();
	}

	return object.take();
	}

	template <unsigned Bitwidth>
	inline char const *ELFObject<Bitwidth>::getSectionName(size_t i) const {
	ELFSectionTy const *sec = stab[header->getStringSectionIndex()];

	if (sec) {
	ELFSectionStrTabTy const &st =
	static_cast<ELFSectionStrTabTy const &>(*sec);
	return st[i];
	}

	return NULL;
	}

	template <unsigned Bitwidth>
	inline ELFSection<Bitwidth> const *
	ELFObject<Bitwidth>::getSectionByIndex(size_t i) const {
	return stab[i];
	}

	template <unsigned Bitwidth>
	inline ELFSection<Bitwidth> *
	ELFObject<Bitwidth>::getSectionByIndex(size_t i) {
	return stab[i];
	}

	template <unsigned Bitwidth>
	inline ELFSection<Bitwidth> const *
	ELFObject<Bitwidth>::getSectionByName(std::string const &str) const {
	size_t idx = getSectionHeaderTable()->getByName(str)->getIndex();
	return stab[idx];
	}

	template <unsigned Bitwidth>
	inline ELFSection<Bitwidth> *
	ELFObject<Bitwidth>::getSectionByName(std::string const &str) {
	ELFObjectTy const *const_this = this;
	ELFSectionTy const *sptr = const_this->getSectionByName(str);
	// Const cast for the same API's const and non-const versions.
	return const_cast<ELFSectionTy *>(sptr);
	}


	template <unsigned Bitwidth>
	inline void ELFObject<Bitwidth>::
	relocateARM(void (find_sym)(void context, char const name),
	void *context,
	ELFSectionRelTableTy *reltab,
	ELFSectionProgBitsTy *text) {
	// FIXME: Should be implement in independent files.
	rsl_assert(Bitwidth == 32 && "ARM only have 32 bits.");

	ELFSectionSymTabTy *symtab =
	static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
	rsl_assert(symtab && "Symtab is required.");

	for (size_t i = 0; i < reltab->size(); ++i) {
	// FIXME: Can not implement here, use Fixup!
	ELFRelocTy rel = (reltab)[i];
	ELFSymbolTy sym = (symtab)[rel->getSymTabIndex()];

	// FIXME: May be not uint32_t *.
	typedef int32_t Inst_t;
	Inst_t inst = (Inst_t )&(*text)[rel->getOffset()];
	Inst_t P = (Inst_t)(int64_t)inst;
	Inst_t A = 0;
	Inst_t S = (Inst_t)(int64_t)sym->getAddress();

	switch (rel->getType()) {
	default:
	rsl_assert(0 && "Not implemented relocation type.");
	break;

	case R_ARM_ABS32:
	{
	A = *inst;
	*inst = (S+A);
	}
	break;

	// FIXME: Predefine relocation codes.
	case R_ARM_CALL:
	{
	#define SIGN_EXTEND(x, l) (((x)^(1<<((l)-1)))-(1<<(l-1)))
	A = (Inst_t)(int64_t)SIGN_EXTEND(*inst & 0xFFFFFF, 24);
	#undef SIGN_EXTEND

	switch (sym->getType()) {
	default:
	rsl_assert(0 && "Wrong type for R_ARM_CALL relocation.");
	abort();
	break;

	case STT_FUNC:
	if (S == 0) {
	rsl_assert(0 && "We should get function address at previous "
	"sym->getAddress() function call.");
	abort();
	}
	break;

	case STT_NOTYPE:
	if (S == 0) {
	void *ext_func = find_sym(context, sym->getName());
	#ifdef SUPPORT_NEAR_JUMP_EVEN_IF_BLc2BLX_NEEDED
	S = (Inst_t)(uintptr_t)ext_func;
	sym->setAddress(ext_func);

	uint32_t result = (S >> 2) - (P >> 2) + A;
	if (result > 0x007fffff && result < 0xff800000) {
	#endif
	#ifndef __arm__
	// We have not implement function stub in this runtime env
	rsl_assert(0 && "Target address is far from call instruction");
	abort();
	#else
	void *stub = text->getStubLayout()->allocateStub(ext_func);
	if (!stub) {
	llvm::errs() << "unable to allocate stub." << "\n";
	exit(EXIT_FAILURE);
	}

	//out() << "stub: for " << ext_func << " at " << stub << "\n";
	sym->setAddress(stub);
	S = (uint32_t)stub;
	#endif
	#ifdef SUPPORT_NEAR_JUMP_EVEN_IF_BLc2BLX_NEEDED
	}
	#endif
	}
	break;
	}

	uint32_t result = (S >> 2) - (P >> 2) + A;

	if (result > 0x007fffff && result < 0xff800000) {
	rsl_assert(0 && "Stub is still too far");
	abort();
	}

	inst = ((result) & 0x00FFFFFF) \| (inst & 0xFF000000);
	}
	break;
	case R_ARM_MOVT_ABS:
	case R_ARM_MOVW_ABS_NC:
	{
	if (S==0 && sym->getType() == STT_NOTYPE)
	{
	void *ext_sym = find_sym(context, sym->getName());
	S = (Inst_t)(uintptr_t)ext_sym;
	sym->setAddress(ext_sym);
	}
	if (rel->getType() == R_ARM_MOVT_ABS) {
	S >>= 16;
	}

	// No need sign extend.
	A = ((inst & 0xF0000) >> 4) \| (inst & 0xFFF);
	uint32_t result = (S+A);
	*inst = (((result) & 0xF000) << 4) \|
	((result) & 0xFFF) \|
	(*inst & 0xFFF0F000);
	}
	break;
	}
	//llvm::errs() << "S: " << (void *)S << '\n';
	//llvm::errs() << "A: " << (void *)A << '\n';
	//llvm::errs() << "P: " << (void *)P << '\n';
	//llvm::errs() << "S+A: " << (void *)(S+A) << '\n';
	//llvm::errs() << "S+A-P: " << (void *)(S+A-P) << '\n';
	}
	}

	template <unsigned Bitwidth>
	inline void ELFObject<Bitwidth>::
	relocateX86_64(void (find_sym)(void context, char const name),
	void *context,
	ELFSectionRelTableTy *reltab,
	ELFSectionProgBitsTy *text) {
	rsl_assert(Bitwidth == 64 && "Only support X86_64.");

	ELFSectionSymTabTy *symtab =
	static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
	rsl_assert(symtab && "Symtab is required.");

	for (size_t i = 0; i < reltab->size(); ++i) {
	// FIXME: Can not implement here, use Fixup!
	ELFRelocTy rel = (reltab)[i];
	ELFSymbolTy sym = (symtab)[rel->getSymTabIndex()];

	//typedef uint64_t Inst_t;
	typedef int32_t Inst_t;
	Inst_t inst = (Inst_t )&(*text)[rel->getOffset()];
	Inst_t P = (Inst_t)(int64_t)inst;
	Inst_t A = (Inst_t)(int64_t)rel->getAddend();
	Inst_t S = (Inst_t)(int64_t)sym->getAddress();

	if (S == 0) {
	S = (Inst_t)(int64_t)find_sym(context, sym->getName());
	sym->setAddress((void *)S);
	}

	switch (rel->getType()) {
	default:
	rsl_assert(0 && "Not implemented relocation type.");
	break;

	// FIXME: XXX: R_X86_64_64 is 64 bit, there is a big problem here.
	case 1: // R_X86_64_64
	*inst = (S+A);
	break;

	case 2: // R_X86_64_PC32
	*inst = (S+A-P);
	break;

	case 10: // R_X86_64_32
	case 11: // R_X86_64_32S
	*inst = (S+A);
	break;
	}
	}
	}

	template <unsigned Bitwidth>
	inline void ELFObject<Bitwidth>::
	relocateX86_32(void (find_sym)(void context, char const name),
	void *context,
	ELFSectionRelTableTy *reltab,
	ELFSectionProgBitsTy *text) {
	rsl_assert(Bitwidth == 32 && "Only support X86.");

	ELFSectionSymTabTy *symtab =
	static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
	rsl_assert(symtab && "Symtab is required.");

	for (size_t i = 0; i < reltab->size(); ++i) {
	// FIXME: Can not implement here, use Fixup!
	ELFRelocTy rel = (reltab)[i];
	ELFSymbolTy sym = (symtab)[rel->getSymTabIndex()];

	//typedef uint64_t Inst_t;
	typedef int32_t Inst_t;
	Inst_t inst = (Inst_t )&(*text)[rel->getOffset()];
	Inst_t P = (Inst_t)(uintptr_t)inst;
	Inst_t A = (Inst_t)(uintptr_t)*inst;
	Inst_t S = (Inst_t)(uintptr_t)sym->getAddress();

	if (S == 0) {
	S = (Inst_t)(uintptr_t)find_sym(context, sym->getName());
	sym->setAddress((void *)S);
	}

	switch (rel->getType()) {
	default:
	rsl_assert(0 && "Not implemented relocation type.");
	break;

	case R_386_PC32:
	*inst = (S+A-P);
	break;

	case R_386_32:
	*inst = (S+A);
	break;
	}
	}
	}

	// TODO: Refactor all relocations.
	template <unsigned Bitwidth>
	inline void ELFObject<Bitwidth>::
	relocate(void (find_sym)(void context, char const name), void *context) {
	// Init SHNCommonDataSize.
	// Need refactoring
	size_t SHNCommonDataSize = 0;

	ELFSectionSymTabTy *symtab =
	static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
	rsl_assert(symtab && "Symtab is required.");

	for (size_t i = 0; i < symtab->size(); ++i) {
	ELFSymbolTy sym = (symtab)[i];

	if (sym->getType() != STT_OBJECT) {
	continue;
	}

	size_t idx = (size_t)sym->getSectionIndex();
	switch (idx) {
	default:
	if ((*shtab)[idx]->getType() == SHT_NOBITS) {
	// FIXME(logan): This is a workaround for .lcomm directives
	// bug of LLVM ARM MC code generator. Remove this when the
	// LLVM bug is fixed.

	size_t align = 16;
	SHNCommonDataSize += (size_t)sym->getSize() + align;
	}
	break;

	case SHN_COMMON:
	{
	size_t align = (size_t)sym->getValue();
	SHNCommonDataSize += (size_t)sym->getSize() + align;
	}
	break;

	case SHN_ABS:
	case SHN_UNDEF:
	case SHN_XINDEX:
	break;
	}
	}
	if (!initSHNCommonDataSize(SHNCommonDataSize)) {
	rsl_assert("Allocate memory for common variable fail!");
	}

	for (size_t i = 0; i < stab.size(); ++i) {
	ELFSectionHeaderTy sh = (shtab)[i];
	if (sh->getType() != SHT_REL && sh->getType() != SHT_RELA) {
	continue;
	}
	ELFSectionRelTableTy *reltab =
	static_cast<ELFSectionRelTableTy *>(stab[i]);
	rsl_assert(reltab && "Relocation section can't be NULL.");

	const char *reltab_name = sh->getName();
	const char *need_rel_name;
	if (sh->getType() == SHT_REL) {
	need_rel_name = reltab_name + 4;
	// ".rel.xxxx"
	// ^ start from here.
	} else {
	need_rel_name = reltab_name + 5;
	}

	ELFSectionProgBitsTy *need_rel =
	static_cast<ELFSectionProgBitsTy *>(getSectionByName(need_rel_name));
	rsl_assert(need_rel && "Need be relocated section can't be NULL.");

	switch (getHeader()->getMachine()) {
	case EM_ARM:
	relocateARM(find_sym, context, reltab, need_rel);
	break;
	case EM_386:
	relocateX86_32(find_sym, context, reltab, need_rel);
	break;
	case EM_X86_64:
	relocateX86_64(find_sym, context, reltab, need_rel);
	break;

	default:
	rsl_assert(0 && "Only support ARM, X86, and X86_64 relocation.");
	break;
	}
	}

	for (size_t i = 0; i < stab.size(); ++i) {
	ELFSectionHeaderTy sh = (shtab)[i];
	if (sh->getType() == SHT_PROGBITS \|\| sh->getType() == SHT_NOBITS) {
	if (stab[i]) {
	static_cast<ELFSectionBitsTy *>(stab[i])->protect();
	}
	}
	}
	}

	template <unsigned Bitwidth>
	inline void ELFObject<Bitwidth>::print() const {
	header->print();
	shtab->print();

	for (size_t i = 0; i < stab.size(); ++i) {
	ELFSectionTy *sec = stab[i];
	if (sec) {
	sec->print();
	}
	}
	}

	#endif // ELF_OBJECT_HXX