[ORC] Use ExecutorAddr::toPtr() in documentation

[vadorovsky]

Summary

Partial move from JITTargetAddress to ExecutorAddr was done in 8b1771bd9f30,
but that change missed the ORC and Kaleidoscope documents which led to
their inconsistency.

Fixes #62411

[lhames]

Looks good to me. Thanks @vadorovsky!

Do you have commit access? If not, please let me know what name and email address you would like used for attribution and I can commit on your behalf.

[vadorovsky]

@lhames I don't have commit access (it's my first contribution ever). You can use

Mike Rostecki <[e-mail]>

for attribution. Thanks!

I see that CI is red (unrelated to this patch). Is there some way to re-trigger the build, or is it fine?

[vadorovsky]

@lhames ping

llvm/docs/ORCv2.rst

if (auto Err = JIT->addIRModule(TheadSafeModule(std::move(M), Ctx)))
     return Err;
 
   // Look up the JIT'd code entry point.
   auto EntrySym = JIT->lookup("entry");
   if (!EntrySym)
     return EntrySym.takeError();
 
   // Cast the entry point address to a function pointer.
-  auto *Entry = (void(*)())EntrySym.getAddress();
+  auto *Entry = EntrySym.getAddress().toPtr<void(*)()>();
 
   // Call into JIT'd code.
   Entry();
 
 The builder classes provide a number of configuration options that can be
 specified before the JIT instance is constructed. For example:
 
 .. code-block:: c++
.. code-block:: c++
   // equivalent to a "links against" relationship in a command-line link.
   auto &MainJD = ES.createJITDylib("main");
   MainJD.addToLinkOrder(&LibA);
   MainJD.addToLinkOrder(&LibB);
   CXXLayer.add(MainJD, MemoryBuffer::getFile("main.cpp"));
 
   // Look up the JIT'd main, cast it to a function pointer, then call it.
   auto MainSym = ExitOnErr(ES.lookup({&MainJD}, "main"));
-  auto *Main = (int(*)(int, char*[]))MainSym.getAddress();
+  auto *Main = MainSym.getAddress().toPtr<int(*)(int, char *[])>();
 
   int Result = Main(...);
 
 This example tells us nothing about *how* or *when* compilation will happen.
 That will depend on the implementation of the hypothetical CXXCompilingLayer.
 The same linker-based symbol resolution rules will apply regardless of that
 implementation, however. For example, if a1.cpp and a2.cpp both define a
 function "foo" then ORCv2 will generate a duplicate definition error. On the

llvm/docs/tutorial/BuildingAJIT1.rst

 
 A basic use-case for this API, executing the 'main' function from a module,
 will look like:
 
 .. code-block:: c++
 
   JIT J;
   J.addModule(buildModule());
-  auto *Main = (int(*)(int, char*[]))J.lookup("main").getAddress();
+  auto *Main = J.lookup("main").getAddress().toPtr<int(*)(int, char *[])>();
   int Result = Main();
 
 The APIs that we build in these tutorials will all be variations on this simple
 theme. Behind this API we will refine the implementation of the JIT to add
 support for concurrent compilation, optimization and lazy compilation.
 Eventually we will extend the API itself to allow higher-level program
 representations (e.g. ASTs) to be added to the JIT.
 

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl04.rst

static void HandleTopLevelExpression() {
           InitializeModuleAndPassManager();
 
           // Search the JIT for the __anon_expr symbol.
           auto ExprSymbol = ExitOnErr(TheJIT->lookup("__anon_expr"));
           assert(ExprSymbol && "Function not found");
 
           // Get the symbol's address and cast it to the right type (takes no
           // arguments, returns a double) so we can call it as a native function.
-          double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress();
+          double (*FP)() = ExprSymbol.getAddress().toPtr<double (*)()>();
           fprintf(stderr, "Evaluated to %f\n", FP());
 
           // Delete the anonymous expression module from the JIT.
           ExitOnErr(RT->remove());
         }
 
 If parsing and codegen succeed, the next step is to add the module containing
 the top-level expression to the JIT. We do this by calling addModule, which