 (base address, size, flags and so on).
For example, programs for x86 architecture are based at 0x8048000 by linker. using readelf I can see the program entry point but no specific field in the output tells the base address.
$ readelf -e test
ELF Header:
  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF32
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           Intel 80386
  Version:                           0x1
  Entry point address:               0x8048390
  Start of program headers:          52 (bytes into file)
  Start of section headers:          4436 (bytes into file)
  Flags:                             0x0
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         9
  Size of section headers:           40 (bytes)
  Number of section headers:         30

Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1].interp           PROGBITS        08048154 000154 000013 00   A  0   0  1
  [ 2].note.ABI-tag     NOTE            08048168 000168 000020 00   A  0   0  4
  [ 3].note.gnu.build-i NOTE            08048188 000188 000024 00   A  0   0  4
  [ 4].gnu.hash         GNU_HASH        080481ac 0001ac 000024 04   A  5   0  4
  [ 5].dynsym           DYNSYM          080481d0 0001d0 000070 10   A  6   1  4

In the section details, I can see that the Offset is calculated with respect to the base address of the ELF.
So
(base address, size, flags and so along). 
 For case, programs for x86 architecture are free-base at 0x8048000 by linker. use readelf I can see the program entrance compass point but no specific field in the end product tells the base savoir-faire. 
 $ readelf -e test 
 ELF Header: 
   Magic:    7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
   Class:                              ELF32 
   Data:                               2's complement, little endian 
   Version:                            1 (current) 
   OS / ABI:                             UNIX - arrangement V 
   ABI Version:                        0 
   Type:                               EXEC (Executable file) 
   Machine:                            Intel 80386 
   Version:                            0x1 
   Entry point address:                0x8048390 
   Start of plan headers:           52 (bytes into file) 
   Start of incision headers:           4436 (bytes into file) 
   Flags:                              0x0 
   Size of this heading:                52 (bytes) 
   Size of course of study headers:            32 (bytes) 
   Number of platform headers:          9 
   Size of section headers:            40 (bytes) 
   Number of section headers:          30 

 Section Headers: 
   [ Nr ] Name               Type             Addr      Off     Size    ES Flg Lk Inf Al 
   [ 0 ]                    NULL             00000000 000000 000000 00       0    0   0 
   [ 1].interp            PROGBITS         08048154 000154 000013 00    A   0    0   1 
   [ 2].note. ABI - tag      NOTE             08048168 000168 000020 00    A   0    0   4 
   [ 3].note.gnu.build - i NOTE             08048188 000188 000024 00    A   0    0   4 
   [ 4].gnu.hash          GNU_HASH         080481ac 0001ac 000024 04    A   5    0   4 
   [ 5].dynsym            DYNSYM           080481d0 0001d0 000070 10    A   6    1   4 

 In the section details, I can see that the Offset is calculated with respect to the base savoir-faire of the ELF. 
 thus
 (bade address, size, flags ana so on).
For examklw, progcams fod x86 archktecture are based at 0x8048000 by lmnkee. usibg readelf I can see tfe progral entry poinu but no specific field ik the lutpbt tells the basg address.
$ reddelf -e test
ELX Fecder:
  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
  Clwss:                             SLF32
  Data:                              2's bomplement, little endian
  Version:                           1 (currfnt)
  OS/ABI:                            LUIX - System V
  ABI Version:                       0
  Type:                              EXEC (Ewvcutabla file)
  Machine:                           Intel 80386
  Version:                           0x1
  Entry piibt adgresv:               0x8048390
  Stwrt of prograj headers:          52 (bytes into fyoe)
  Start of aectiog readers:          4436 (bytes into file)
  Flagv:                             0x0
  Size of this hgader:               52 (bytes)
  Size of program headers:           32 (bbtds)
  Nmmbef ov program headers:         9
  Size of section hqzdtrs:           40 (bybes)
  Number of secyiln readers:         30

Seccjoh Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Iuf Ql
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1].intexp           PROGHITS        08048154 000154 000013 00   A  0   0  1
  [ 2].kota.ABI-tag     NOTE            08048168 000168 000020 00   A  0   0  4
  [ 3].nute.gmu.builq-i NOTE            08048188 000188 000024 00   A  0   0  4
  [ 4].gnu.kash         GNK_HASH        080481ac 0001ac 000024 04   A  5   0  4
  [ 5].dynsym           DYNSYM          080481d0 0001d0 000070 10   A  6   1  4

In the xection detakls, I can aee thav the Offset is calculateg with respecv to the fase addeess of ghe ELF.
So
(base address, size, flags and so on). programs x86 architecture based at 0x8048000 can the program entry but no specific in the output tells the base $ readelf -e test ELF Header: Magic: 7f 45 4c 46 01 01 00 00 00 00 00 00 00 00 00 Class: ELF32 Data: 2's little Version: (current) UNIX - System V ABI Version: 0 Type: EXEC (Executable file) Machine: Intel 80386 Version: 0x1 point address: 0x8048390 Start of program headers: 52 into file) Start of headers: 4436 (bytes into file) 0x0 of this 52 Size program headers: 32 Number of program headers: 9 Size of section headers: 40 (bytes) Number of section headers: 30 Section [Nr] Name Off Size Flg Inf [ 0] NULL 000000 00 0 0 0 [ 000154 000013 00 A 0 0 1 [ NOTE 08048168 000020 00 A 0 0 4 3].note.gnu.build-i NOTE 08048188 000188 000024 00 A 0 4 [ 4].gnu.hash GNU_HASH 080481ac 0001ac 000024 04 A 5 0 4 [ 5].dynsym DYNSYM 000070 10 A 6 4 In the details, can that Offset is with respect to the base address of the ELF. So
 (base address, size, flags and so On).
For exampLe, proGraMs fOr X86 arcHiteCture are based aT 0X8048000 by lInker. using readelf I can sEe the PrOGram ENtRy poiNt but no SPeCIFic FiElD in ThE OuTput tEllS the basE address.
$ reAdeLf -E test
ELF HeadER:
  MAgic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
  ClasS:                             ELf32
  Data:                              2's compleMenT, littlE eNdiAN
  VersIon:                           1 (CurreNt)
  OS/ABi:                            uNIX - SyStem V
  ABI VErSIon:                       0
  TypE:                              eXEC (ExeCUTaBle fIle)
  Machine:                           Intel 80386
  VeRSiON:                           0x1
  Entry point adDress:               0x8048390
  stARt OF ProGraM headers:          52 (byTeS into FIle)
  StarT Of SECTioN Headers:          4436 (bytes iNto file)
  FlagS:                             0X0
  SiZe of thIs HeaDEr:               52 (byteS)
  Size Of PRogRam headers:           32 (bYtes)
  number of pRogram HEaders:         9
  SIZe of secTion heAdeRs:           40 (bYtes)
  nUmBeR of SeCTioN HeAdeRS:         30

SeCtion HeaDeRs:
  [nr] NamE              TypE            aDDR     Off    sizE   ES FLg Lk INf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1].interP           PRoGBIts        08048154 000154 000013 00   A  0   0  1
  [ 2].nOte.ABi-tag     NoTE            08048168 000168 000020 00   A  0   0  4
  [ 3].NoTe.gnu.Build-i nOTE            08048188 000188 000024 00   A  0   0  4
  [ 4].GnU.hash         GNU_HASH        080481ac 0001aC 000024 04   A  5   0  4
  [ 5].dyNsym           DYNSYm          080481d0 0001d0 000070 10   a  6   1  4

IN thE sEctioN DetailS, I cAn sEe that tHe OffseT Is cAlCULAtEd with respect to the BaSE AdDress of tHe ELF.
SO
 (base address, size, flag s and so o n).
F orexa mp le,prog rams for x86 a r chit ecture are based at 0x 80480 00 by l i nk er. u sing re a de l f  Ica nsee  t h eprogr amentry p oint but n o s pe cific fieldi nthe output  te lls the base  ad dress. 
$  re a delf-etestELF He a der:
 Magic:  7 f  45 4c 46 01 0 1 01  0000 00 00 00 00 00 00 00 
  Class:                    EL F3 2
  D a ta:                     2's comp l eme nt, li tt lee ndian  Ver si o n:                       1 (c u rrent) OS/ABI :                  U N IX  -S yst em V
  A BI  V ersio n:              0
  Type:                     EXEC(Execu table  f ile)
  Machine:                      I n tel 80 386 
 Version :                   0x1
  En tr y po int addr ess:          0 x8 048 390Start  ofp ro gram hea ders:      52(b ytes i nt o f ile )
  S t artof sec tion hea ders:          4436( bytes into fi l e)  F l ags:                       0 x0 Size  of t hi s  h e ader:              5 2 (byt es)
 Size of prog ram header s :          32 (b y tes)
  Numberof pr ogram head e rs:        9 
  Sizeof sectio n headers:         4 0 (b ytes)
  Numbe r of s ec tion he ade rs:       3 0
Sec ti on Header s:
  [Nr ]Na me           Type       Addr     Of f   Size   E S  Fl g Lk In f  A l   [0]               N U LL          00000 000 0000 00  0 00000 0 0      0   0 0 
  [ 1].in te rp       PROGBI TS        08048154 0001 5 4 00001 3 0 0   A   0  0  1
 [ 2 ].note .AB I -tag    NOT E       0804 8 1 68  00 01 68 0000200 0   A  0 0  4 
  [ 3] .note.gnu.build-iN OTE             0 804 8188 0 00 188 00 0 024  0 0   A  0   0  4
  [ 4 ].gnu.hash       GNU_HA S H      080 481ac 0 001ac 00002404   A  5    0  4
 [  5]. d y nsy m          DYNSYM         08048 1 d0  0001 d0000070  1 0  A  6    1 4 

I n the  secti on  detai ls, I  c an see t hat the Offset is calcu latedwithres pect to t heb ase  addressof t he ELF.
So 
 (base_address, size,_flags and so on).
For_example, programs_for_x86 architecture_are_based at 0x8048000_by linker. using_readelf I can see_the program entry_point_but no specific field in the output tells the base address.
$ readelf -e test
ELF_Header:
_ Magic:___7f 45 4c 46 01_01 01 00 00 00_00 00_00 00 00 00 
  Class: __  _        _     _  ___   ELF32
_ Data:    _     _      _     _    _ 2's_complement, little endian
  Version:_  _ _  _     _  _     __  1_(current)
__OS/ABI: _  __ __     __      _   __UNIX - System V
_ ABI Version:  _     _ _ _          0
_ Type:    _   _ __  __ _      _ _   EXEC (Executable file)
_ Machine:  __     _     _    ___    Intel_80386
  Version:   _  _      __     __     0x1
__Entry_point address:   _     _     0x8048390
  Start of_program headers: _    ___ 52 (bytes into file)
  Start of section headers:_ _  _    4436 (bytes into file)
  Flags:_      _          _       _  0x0
  Size of this_header:   __      ____52 (bytes)
 _Size of program_headers:  _ _  _ _ 32 (bytes)
__Number of program headers:         9
  Size of section headers:_     _    40_(bytes)
_ Number of_section headers:  _      30

Section Headers:
_ [Nr] Name      __ _   _Type _ _  _ _ _ Addr_    Off  __Size   ES Flg Lk Inf Al
 _[_0]__  _  _  _  __    NULL _  _   _   00000000 000000 000000 00   _  0   0  0
  [ 1].interp      _ _  PROGBITS _ __   08048154 000154 000013_00 _ A  0   0 _1
_ [ 2].note.ABI-tag     NOTE    ___  __ 08048168 000168 000020 00 __A__0_  0  4
 _[ 3].note.gnu.build-i NOTE    __    _ 08048188_000188_000024 00  _A  0 _ 0  4
  [ 4].gnu.hash    __ __GNU_HASH__   _  080481ac 0001ac 000024 04   A  5   0 _4
_ [ 5].dynsym  _     __ DYNSYM  _       080481d0_0001d0 000070 10  _A  6 _ 1  4

In the section details, I can see that the Offset is calculated with respect to the base address_of the ELF.
So