MAP file: Pointer to be the address it is pointing to (instead of pointer address itself)?

When the map file is generated, is it possible that the memory address location can be made to be the address that the pointer is pointing to, rather than the address of the pointer itself ?
 
For example,

• I have a pointer called *myPointer
• the address of *myPointer is 0x35D8
• the address *myPointer is pointing to is 0x363E

So the map file will show:

• 0x35D8        myPointer

But I actually want it to show :

• 0x363E        myPointer

 
I am using Simulink Coder to generate code from a Simulink model.  The input and output signals to the Simulink model are interfaced to variables within the platform software (hand written C code) using pointers which are externally declared in a source and header interface file.
 
For example, the source interface file will contain:
 
unit16 *myPointer=&analogueInput;
 
And the header interface file will contain:
 
extern unit16 *myPointer=&analogueInput;
 
The platform software will store data in the variable in 'analogueInput' and 'myPointer' will point to the address of the variable 'analogueInput'.
 
In the Simulink model, the signal 'myPointer' has the option "Signal name must resolve to Simulink signal object" selected and the storage class for the Simulink signal object is set to "ImportedExternPointer".  This means that the signal 'myPointer' in the Simulink model is declared externally and will not be declared by the code that it generates.  Instead it will use the declarations made externally in the interface source and header files.
 
I am also using Vector CANape (a calibration tool to log signals and change parameters via CAN).  This is where the problem occurs, because it is not possible to log the input and output signals in the Simulink model.  This is because the address locations of the input and output signals are the address of the pointer, not the address of the variable it is pointing to.  Hence the reason for my question.
 
I am using a dsPIC33EP256MU810 processor with MPLAB X and the XC16 compiler.

The calibration tool Vector CANape uses a protocol called CCP (CAN Calibration Protocol).
 
CANape requires a database file which contains the names of signals that can be logged or calibration parameters that can be changed, along with the datatype, its scaling and most importantly the address of the signal or calibration parameter.  Using the example in my original post, the a2l file would contain:
 
/begin MEASUREMENT
/* Name */ myPointer
/* Long identifier */ "Analogue input"
/* Data type */ UWORD
/* Conversion method */ uint16
/* Resolution (Not used) */ 0
/* Accuracy (Not used) */ 0
/* Lower limit */ 0
/* Upper limit */ 65535
ECU_ADDRESS 0x35D8
/end MEASUREMENT
 
Note that the ECU_ADDRESS is the address of the pointer, not the address it is pointing to.  So if I tried to log this signal in CANape it would display the value of the address it is pointing to (i.e. 0x363E) rather than the value for the variable 'analogueInput' which is in address 0x363E.
 
The a2l file is generated using the MAP file - it extracts the address locations for the all the signals and calibration parameters.
 
If the MAP file contained the address that the pointer is pointing to (instead of the pointer address itself), then the address in the a2l file would be correct and I would be able to log the signal 'analogueInput'.  For example:
 
/begin MEASUREMENT
/* Name */ myPointer
/* Long identifier */ "Analogue input"
/* Data type */ UWORD
/* Conversion method */ uint16
/* Resolution (Not used) */ 0
/* Accuracy (Not used) */ 0
/* Lower limit */ 0
/* Upper limit */ 65535
ECU_ADDRESS 0x363E
/end MEASUREMENT
 
 
 
 
 
 

To use your example, MyPointer will have a RAM address assigned to it by the linker (tied to a value you specify, if you so decide), and AnalogInput will also have an address assigned to it.  So, you really do have the value you want in the map file, it's just the address of AnalogInput (not MyPointer).  You can have your debugger watch window show the value of *MyPointer, but there is no way the linker can know (and put into the map file) what value you are going to assign to the pointer once your program runs. 
If the pointer is always going to point to the same location, then you don't need a pointer at all- just reference the value directly in your program.  A pointer which never changes is a waste of resources, and bloats your program with unnecessary de-referencing with no compensating benefit.