Adding a const string identifier to at the start location of functions in C
Sorry, but your idea won't work at all, for numerous reasons (see the bottom of this answer). You can't use strings for this. You should enumerate the functions with an unique index instead. The standard way is to use an enum.
Preferably, you should ensure data integrity of the table at compile-time. I wouldn't recommend having read/write function-pointer tables unless you have a very specialized case.
With a standard C compiler, you can do this:
typedef void func_t (void); // the function type

typedef enum
{
  FUNC_FOO,
  FUNC_BAR,
  FUNC_N  // represents the number of functions supported
} func_id_t;

func_t* const fntable [] =    // a read-only table of function pointers
{
  [FUNC_FOO] = foo,
  [FUNC_BAR] = bar,
};

_Static_assert(sizeof fntable / sizeof *fntable == FUNC_N, &quot;fntable corrupt&quot;);

...

func_t* pFoo = fntable [FUNC_FOO];


Misc notes:

char* pFooId = (char*)FnTable[0]; wouldn't work reliably even if the string was stored inside the function. This is a highly fishy cast - we cannot go from function pointers to object pointers or the other way around. C doesn't specify what will happen - it is undefined behavior.
If you know the physical address layout, you could convert a function pointer to uintptr_t, which is a portable integer type. Then do all arithmetic on that integer type, and from there you can go to object pointers if necessary.

What you attempted wouldn't work regardless, because if you had managed to allocate a const string, it would go into the .rodata section of the memory and not likely into the part of .text where the function itself is allocated. Strings in particular tend to be stored together by compilers, in order to utilize optimization techniques like &quot;string pooling&quot;. Please study What resides in the different memory types of a microcontroller?. And the first binary you'd encounter inside the function would be related to ABI calling convention stacking of parameters etc anyhow.

Please note that you can use the standard feature __func__ inside a function, to get the equivalent of a static char[] null-terminated string containing the function's name &quot;Foo&quot; etc. So you could have done something like static const char* ptr = __func__; inside each function.

Never declare functions with empty parenthesis void foo() in C. That is obsolete style (since 20 years back!) and means that the function will accept any parameter. Instead, use void foo (void). C and C++ are different here.