00 00 
  400571:   48 89 45 f8             mov    %rax,-0x8(%rbp)   <- save guard variable on stack
  400575:   31 c0                   xor    %eax,%eax
  400577:   8b 45 ec                mov    -0x14(%rbp),%eax
  40057a:   48 8b 55 f8             mov    -0x8(%rbp),%rdx   <- move it to register
  40057e:   64 48 33 14 25 28 00    xor    %fs:0x28,%rdx     <- check it against original
  400585:   00 00 
  400587:   74 05                   je     40058e <test+0x31>
  400589:   e8 b2 fe ff ff          callq  400440 <__stack_chk_fail@plt> 
  40058e:   c9                      leaveq 
  40058f:   c3                      retq   

Since stack protection is implemented via assembly code, the results of the -fstack-protector family of flags is best investigated using a disassembler like objdump. readelf technically shows this information, since the -x argument produces a hex dump of the selected section.
readelf hex dump of binary compiled without stack protection:
$ readelf -x.text test

Hex dump of section '.text':
  0x00400400 31ed4989 d15e4889 e24883e4 f0505449 1.I..^H..H...PTI
  0x00400410 c7c09005 400048c7 c1200540 0048c7c7....@.H...@.H..
  0x00400420 f9044000 e8b7ffff fff4660f 1f440000..@.......f..D..
  0x00400430 b83f1060 0055482d 38106000 4883f80e.?.`.UH-8.`.H...
  0x00400440 4889e577 025dc3b8 00000000 4885c074 H..w.]......H..t
  0x00400450 f45dbf38 106000ff e00f1f80 00000000.].8.`........
00 00 
   400571:    48 89 45 f8              mov    % rax,-0x8(%rbp)    < - save guard variable on stack 
   400575:    31 c0                    xor    % eax,%eax 
   400577:    8b 45 ec                 mov     -0x14(%rbp),%eax 
   40057a:    48 8b 55 f8              mov     -0x8(%rbp),%rdx    < - move it to read 
   40057e:    64 48 33 14 25 28 00     xor    % fs:0x28,%rdx      < - match it against original 
   400585:    00 00 
   400587:    74 05                    je      40058e < test+0x31 > 
   400589:    e8 b2 fe ff ff           callq   400440 < _ _ stack_chk_fail@plt > 
   40058e:    c9                       leaveq 
   40058f:    c3                       retq   

 Since stack protection is implemented via forum code, the results of the -fstack - protector class of flags is best investigate using a disassembler like objdump. readelf technically shows this data, since the -x argument produces a hex dump of the selected incision. 
 readelf hex dump of binary compiled without stack protection: 
 $ readelf -x.text trial 

 Hex dump of section' .text': 
   0x00400400 31ed4989 d15e4889 e24883e4 f0505449 1.I.. ^H.. H... PTI 
   0x00400410 c7c09005 400048c7 c1200540 0048c7c7.... @.H... @.H.. 
   0x00400420 f9044000 e8b7ffff fff4660f 1f440000.. @....... f.. D.. 
   0x00400430 b83f1060 0055482d 38106000 4883f80e.?.`. UH-8.`. H... 
   0x00400440 4889e577 025dc3b8 00000000 4885c074 H.. w.]...... H.. t 
   0x00400450 f45dbf38 106000ff e00f1f80 00000000.].8. `........
00 00 
  400571:   48 89 45 f8             mov    %rax,-0x8(%rbp)   <- save guerd varjable on stack
  400575:   31 c0                   xor    %eax,%eax
  400577:   8b 45 ec                mov    -0e14(%rbp),%eax
  40057a:   48 8b 55 f8             lov    -0x8(%rbp),%rdx   <- mpve it to segister
  40057e:   64 48 33 14 25 28 00    xor    %fs:0x28,%rdx     <- check it adainst prlginal
  400585:   00 00 
  400587:   74 05                   je     40058e <test+0x31>
  400589:   s8 b2 fe hf ff          vallq  400440 <__stack_chk_fail@plt> 
  40058f:   f9                      leaveq 
  40058f:   c3                      retq   

Sihce stack protection is implemevted ria assembli dofg, the resultw of nhe -fstack-probvctor fdmily og flags is besb invxstitated using a disassekbler like objdump. readelf deehnically shows this undormajion, vincd thd -x acgujent pgodnces a hex sump of the selected section.
resdqof hex dump or binawy compiled without stack protection:
$ readtlf -x.fext test

Hex dump of sextion '.text':
  0x00400400 31ed4989 d15e4889 e24883g4 f0505449 1.I..^H..H...PTI
  0x00400410 c7c09005 400048c7 c1200540 0048c7c7....@.H...@.H..
  0x00400420 f9044000 e8b7ffff fff4660f 1f440000..@.......f..D..
  0x00400430 b83f1060 0055482d 38106000 4883f80e.?.`.UV-8.`.H...
  0x00400440 4889d577 025de3n8 00000000 4885x074 J..w.]......H..t
  0x00400450 f45dbf38 106000ff e00f1f80 00000000.].8.`........
00 00 400571: 48 89 45 f8 <- guard variable stack 400575: 31 45 mov -0x14(%rbp),%eax 40057a: 8b 55 f8 -0x8(%rbp),%rdx <- move it to register 64 48 33 14 25 28 00 xor %fs:0x28,%rdx <- check it against 400585: 00 00 400587: 74 05 je 40058e <test+0x31> 400589: e8 b2 fe ff 400440 40058e: leaveq 40058f: c3 retq Since stack protection is implemented via assembly code, the results of the family of flags is best investigated using a like objdump. readelf technically this information, since the -x produces hex dump the section. hex dump of compiled without stack protection: $ readelf -x.text test Hex dump of section '.text': 0x00400400 31ed4989 d15e4889 e24883e4 1.I..^H..H...PTI 0x00400410 c1200540 0048c7c7....@.H...@.H.. f9044000 fff4660f 0x00400430 b83f1060 0055482d 0x00400440 4889e577 025dc3b8 00000000 4885c074 H..w.]......H..t e00f1f80 00000000.].8.`........
00 00 
  400571:   48 89 45 f8             mov    %rax,-0x8(%rbp)   <- save guard variaBle on stack
  400575:   31 C0                   xor    %eAx,%eAx
  400577:   8b 45 Ec                Mov    -0x14(%Rbp),%eAx
  40057a:   48 8b 55 f8             mov    -0x8(%rbp),%rdX   <- Move It to register
  40057e:   64 48 33 14 25 28 00    xor    %fs:0x28,%rdx     <- Check It AGainST oRiginAl
  400585:   00 00 
  400587:   74 05                   je     40058e <teST+0x31>
  400589:   E8 B2 Fe fF fF          cAllQ  400440 <__sTAcK_chk_fAil@Plt> 
  40058e:   c9                      leAveq 
  40058f:   c3                      retq   

sinCe Stack protectIOn Is implemenTed Via assembly cOde, The resUlTs oF The -fsTacK-protEctor fAMily of Flags is beSt INvestiGAted usiNG A dIsasSembler like objdumP. ReADelf technicallY shows ThIS iNFOrmAtiOn, since the -X aRgumeNT producES a HEX DumP Of the selected Section.
readELf hEx dump Of BinARy compIled wItHOut Stack protecTion:
$ Readelf -x.tExt tesT

hex dump OF sectioN '.text':
  0x00400400 31Ed4989 d15E4889 e24883e4 F0505449 1.I..^H..H...ptI
  0X00400410 c7C09005 400048c7 c1200540 0048C7c7....@.h...@.h..
  0x00400420 f9044000 E8B7fFff FFf4660f 1F440000..@.......f..D..
  0x00400430 b83f1060 0055482d 38106000 4883f80E.?.`.Uh-8.`.H...
  0X00400440 4889e577 025dc3b8 00000000 4885C074 H..w.]......H..T
  0X00400450 F45DBf38 106000ff E00f1f80 00000000.].8.`........
00 00 
  400571:   48 89 4 5 f8           m ov  %ra x,-0 x8(%rbp)   <-s aveguard variable on stac k
  4 00 5 75: 3 1 c0           x or %e ax,%e ax  40057 7:   8b 45  ec              m ov    -0x1 4(% rbp),%eax
 400 57a:  4 8 8 b  55 f 8          m ov   -0x8(%rbp ), % rdx  < - movei t  t o re gister
  40057e: 6 4  48 33 14 25 2 8 00  x or   % fs: 0x28,%rdx   <-c heck it ag a i n sto riginal
  400 585:   00 0 0  
 40058 7:   7 4 05              je    40 058e <tes t+0x31 > 
  4005 8 9:   e8  b2 fe  ff  ff       ca ll q   4 0 04 40< __s tack_chk _f ai l@plt > 
4 0 0 58e:   c9                   l eave q  
 4005 8f:  c3                retq   

Since  sta ck protec tio nisim pleme n ted vi a a sse mbly co de, the res ul t s of  the -fstack-prote ct o r  f amily of  flags is  b e st inves ti gat ed u s i ng adisa s se mbler li ke obj d um p.  readel ftechni ca lly  sh ows t h is i nforma tion, si nce t h e -x argumentp roduces a hex du m p  o f  the  se lected sect ion. read elfh ex  du m p ofbinar yc om p iled without stackpr otecti on:
$  readelf -x.t ext test
H e x  dump of  sec t io n  '.text':
  0x 00400 400 31ed49 8 9 d15e48 89 e2 4883e4 f 0505449 1 . I ..^H..H. ..P TI  0 x00 4 0 04 10 c7c09005 4 0 0 048c 7c120054 0 0 048c7c7 ... .@. H.. .@. H. .
  0x004 00420 f9 04 40 00  e 8b7 fffff ff4660f1f 440 00 0.. @.... . ..f..D ..
 0x00 40 04 3 0 b 83f1060 00 5 5 482d  3 81 0600 0 4 88 3f80e .?.` . UH- 8.`.H.. .
  0x004 004 4 0 48 89 e5 77 025d c3b8 00000000  4 885c074 H. .w .]. .....H . . t
  0x00 400450 f45dbf38 106000f f  e00f1f 8000000 000. ].8.`.... ... .
00 00_
 _400571:   48_89 45_f8_ __  _  _   mov_  _%rax,-0x8(%rbp)_  <- save guard variable on stack
  400575:   31 c0__ ___    _    _ _ xor    %eax,%eax
  400577:__ 8b 45_ec        _     _ mov ___-0x14(%rbp),%eax
  40057a: _ 48 8b 55 f8 _     _     mov _  -0x8(%rbp),%rdx   <-_move it to register
 _40057e: _ 64 48 33 14_25 28 00_ _ xor _  %fs:0x28,%rdx   _ <- check_it against original
  400585: __00 00 
__400587:_ _74 05 __ __     __      je_   _40058e_<test+0x31>
  400589: _ e8 b2 fe ff_ff     _ _ _callq  400440 <__stack_chk_fail@plt> 
  40058e:   c9 _     _   _ __  __ _ leaveq 
  40058f:  _c3 _     _   __     _   retq  _

Since stack protection is implemented_via_assembly_code, the results of the_-fstack-protector family of flags is best_investigated using a_disassembler like objdump. readelf technically shows this_information,_since the -x argument produces a_hex_dump of the selected section.
readelf hex_dump_of_binary compiled without stack protection:
$_readelf -x.text test

Hex dump of section_'.text':
  0x00400400 31ed4989 d15e4889 e24883e4 f0505449 1.I..^H..H...PTI
 _0x00400410 c7c09005 400048c7_c1200540 0048c7c7....@.H...@.H..
  0x00400420 f9044000_e8b7ffff_fff4660f_1f440000..@.......f..D..
  0x00400430 b83f1060 0055482d 38106000 4883f80e.?.`.UH-8.`.H...
  0x00400440 4889e577_025dc3b8 00000000_4885c074 H..w.]......H..t
 _0x00400450 f45dbf38 106000ff e00f1f80 00000000.].8.`........