You can find all the exporter symbols by looking at the contents of the object file. On Windows you can use a program such as dumpbin for this and on Linux, nm is the droid you're looking for.
This will not, however, show you the "internal" symbols; symbols not exported in the object file.
If you only want a specific subset of the functions and you control the source for them, you could probably write some kind of horrible macro to store the names of the functions somewhere (you'd have to change every function declaration you were interested in if you went down this route). I wouldn't recommend this at all, but it's there as a last resort.
If you're talking about runtime inspection, then you'll be sad there hear that C++ does not have any kind of built-in reflection. There are different degrees of meta-data that can be made available through libraries (see here, but fundamentally this is something that needs to happen inside the compiler as a lot of information is lost after that stage of translation.
If you need access to this information at runtime then your best bet is probably to "preprocess" the object files (using the object file inspection programs I mentioned earlier), write this to a file and then have your program read this file back in to build up the std::list
you mention.
It's also worth asking yourself why you want to do this; there might be a far more appropriate solution out there for your real problem (see XY problem).
Update
Now you've updated your post with why you want to do this, it all makes a lot more sense. If you're looking to memoise function calls then you could take a look at perfect forwarding and variadic templates; you could store a "cache" of function parameters and return the result if it's already been called with that before.
You don't want to apply this globally, as some functions are not pure functions (i.e. they have side effects and memoising them could break a lot of code); make sure you let your user choose which functions are memoised.