RELOC_HIDE

/*                                                                                                                                                      
 * This macro obfuscates arithmetic on a variable address so that gcc                                                                                   
 * shouldn't recognize the original var, and make assumptions about it.                                                                                 
 *                                                                                                                                                      
 * This is needed because the C standard makes it undefined to do                                                                                       
 * pointer arithmetic on "objects" outside their boundaries and the                                                                                     
 * gcc optimizers assume this is the case. In particular they                                                                                           
 * assume such arithmetic does not wrap.                                                                                                                
 *                                                                                                                                                      
 * A miscompilation has been observed because of this on PPC.                                                                                           
 * To work around it we hide the relationship of the pointer and the object                                                                             
 * using this macro.                                                                                                                                    
 *                                                                                                                                                      
 * Versions of the ppc64 compiler before 4.1 had a bug where use of                                                                                     
 * RELOC_HIDE could trash r30. The bug can be worked around by changing                                                                                 
 * the inline assembly constraint from =g to =r, in this particular                                                                                     
 * case either is valid.                                                                                                                                
 */                                                                                                                                                     
#define RELOC_HIDE(ptr, off)                    \                                                                                                       
  ({ unsigned long __ptr;                   \                                                                                                           
    __asm__ ("" : "=r"(__ptr) : "0"(ptr));      \                                                                                                       

    (typeof(ptr)) (__ptr + (off)); }) 

作用：隐藏的指针和对象的关系