Compiler: hexpru produces wrong address for shared memory

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pruss/prussdrv.h>
#include <pruss/pruss_intc_mapping.h>

///#define USE_PASM

#define PRU_NUM 0
#ifdef USE_PASM
#	define PRU_CODE "./test_pru.bin"
#else
#	define PRU_CODE "./test_pru_code.bin"
#endif

//**********************************************************
// PRU Internal Registers
static char	*Cycle;				// PRU Cycle Counter 
static char	*PruCtl;			// PRU Control Register 
//**********************************************************

/*** pru_setup() -- initialize PRU and interrupt handler
Initializes the PRU specified by PRU_NUM and sets up PRU_EVTOUT_0 handler.
Returns 0 on success, non-0 on error.
***/
static int pru_setup(const char * const path) {
	int rtn;

	tpruss_intc_initdata intc = PRUSS_INTC_INITDATA;
	if(!path) {
	  fprintf(stderr, "pru_setup(): path is NULL\n");
	  return -1;
	}

	// initialize the library, PRU and interrupt
	if(access( PRU_CODE, F_OK ) == -1 ){
		printf("%s does not exist\n", PRU_CODE);
		return -1;
	}
	if((rtn = prussdrv_init()) != 0) {
	  fprintf(stderr, "prussdrv_init() failed\n");
	  return rtn;
	}

	/* open the interrupt */
	if((rtn =  prussdrv_open(PRU_EVTOUT_0)) != 0) {
	  fprintf(stderr, "prussdrv_open() failed\n");
	  return rtn;
	}
	/* initialize interrupt */
	if((rtn = prussdrv_pruintc_init(&intc)) != 0) {
	  fprintf(stderr, "prussdrv_pruintc_init() failed\n");
	  return rtn;
	}
	return rtn;
}
/*** pru_cleanup() -- halt PRU and release driver

Performs all necessary de-initialization tasks for the prussdrv library.

Returns 0 on success, non-0 on error.
***/
static int pru_cleanup(void) {
   int rtn = 0;

   /* clear the event (if asserted) */
   if(prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT)) {
      fprintf(stderr, "prussdrv_pru_clear_event() failed\n");
      rtn = -1;
   }

   /* halt and disable the PRU (if running) */
   if((rtn = prussdrv_pru_disable(PRU_NUM)) != 0) {
      fprintf(stderr, "prussdrv_pru_disable() failed\n");
      rtn = -1;
   }

   /* release the PRU clocks and disable prussdrv module */
   if((rtn = prussdrv_exit()) != 0) {
      fprintf(stderr, "prussdrv_exit() failed\n");
      rtn = -1;
   }
	printf("PRU Stopped\n");
   return rtn;
}
//*****************************************************************************

void print_buf(const char *name, char *buf, int len){

	printf("%s @%08X = ", name, buf);///
	for(int i=0; i<len; i++){
		printf("%02X ", (buf)[i]);
		if(i && ((i % 16) == 15)){
			printf("\n             ");
			for(int n=0; n<strlen(name); n++) printf(" ");
		}
	}
	printf("\n");
}
//*****************************************************************************

int main(){
	int i;

	/* Invoke PRU */
	if(pru_setup(PRU_CODE)){
		printf("%s open failed\n", PRU_CODE);
		pru_cleanup();
		return -1;
	}
/* Shared buffer between ARM and PRU0 */
#	ifdef USE_PASM 
		static void *buffer;
		int shared_size = 100;
		prussdrv_map_prumem(PRU_NUM, &buffer);
#	else
		int shared_size = 200;
		extern volatile char shared_buf[];
		static void *share_mem = (void *)shared_buf;

		prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &share_mem);
///		volatile void *buffer = (volatile void *)((long)share_mem + (long)shared_buf);	// does not work!
		volatile void *buffer = (volatile void *)((long)share_mem + (long)shared_buf - (long)0x222B0);
///		volatile void *buffer = (volatile void *)((long)share_mem + (long)0xE0);

printf("share_mem = %X shared_buf = %X\n", (int)share_mem, (int)shared_buf);///
#	endif

	// Clear the buffer
	for(int i=0; i< shared_size; i++) ((char *)buffer)[i]=0;

	print_buf("buffer", (char *)buffer, shared_size);

	if(prussdrv_pru_reset(PRU_NUM) < 0){
		printf("PRU%d: Reset failed\n", PRU_NUM);
		pru_cleanup();
		return -1;
	}
 	usleep(100000);
	if(prussdrv_exec_program(PRU_NUM, PRU_CODE) < 0){
		printf("PRU%d: %s execute failed\n", PRU_NUM, PRU_CODE);
		pru_cleanup();
		return -1;
	}
	usleep(100000);

	/* Perform a read from the shared buffer */
	print_buf("buffer", (char *)buffer, shared_size);

	pru_cleanup();
	return(0);
}
   

#define CLOCK 200000000		// PRU is always clocked at 200MHz

volatile char shared_buf[100] __attribute__((cregister("PRUDMEM")));
volatile char shared_buf[100];

volatile register unsigned int __R30;

void uSleep(int uSecs){
	int uSec;
	for(uSec=0; uSec<uSecs; uSec++){
		__delay_cycles(CLOCK / 1000000);	// Delay 1 uSec
	}
}

void sendBit(char val){
	if(val & 1)	{	__R30 |=  (1<<5);	}
	else		{	__R30 &= ~(1<<5);	}
	uSleep(833);
}

void sendByte(unsigned char b){
	int i;

	sendBit(0);				// Start bit
	for(i=0; i<8; i++){
		sendBit(b & 1);		// Data bits
		b >>= 1;
	}
	sendBit(1);				// Stop bits
	sendBit(1);
}

int main()
{
	int ix=0;
	while(1){        
		for (ix=64; ix<96; ix++){
			shared_buf[ix] = ix*3;
		}
///		sendByte(0x0A);
///		sendByte(0x0D);
   }
}