[ORC] Add a 'Callable' flag to JITSymbolFlags.

The callable flag can be used to indicate that a symbol is callable. If present,
the symbol is callable. If absent, the symbol may or may not be callable (the
client must determine this by context, for example by examining the program
representation that will provide the symbol definition).

This flag will be used in the near future to enable creation of lazy compilation
stubs based on SymbolFlagsMap instances only (without having to provide
additional information to determine which symbols need stubs).

llvm-svn: 338649

1 files changed, 28 insertions, 11 deletions

diff --git a/llvm/lib/ExecutionEngine/Orc/Layer.cpp b/llvm/lib/ExecutionEngine/Orc/Layer.cpp
index b9da3b7fb8d..49bc54aede8 100644
--- a/llvm/lib/ExecutionEngine/Orc/Layer.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/Layer.cpp
@@ -68,29 +68,46 @@ ObjectLayer::ObjectLayer(ExecutionSession &ES) : ES(ES) {}
 ObjectLayer::~ObjectLayer() {}
 
 Error ObjectLayer::add(VSO &V, VModuleKey K, std::unique_ptr<MemoryBuffer> O) {
-  return V.define(llvm::make_unique<BasicObjectLayerMaterializationUnit>(
-      *this, std::move(K), std::move(O)));
+  auto ObjMU = BasicObjectLayerMaterializationUnit::Create(*this, std::move(K),
+                                                           std::move(O));
+  if (!ObjMU)
+    return ObjMU.takeError();
+  return V.define(std::move(*ObjMU));
 }
 
-BasicObjectLayerMaterializationUnit::BasicObjectLayerMaterializationUnit(
-    ObjectLayer &L, VModuleKey K, std::unique_ptr<MemoryBuffer> O)
-    : MaterializationUnit(SymbolFlagsMap()), L(L), K(std::move(K)),
-      O(std::move(O)) {
-
+Expected<std::unique_ptr<BasicObjectLayerMaterializationUnit>>
+BasicObjectLayerMaterializationUnit::Create(ObjectLayer &L, VModuleKey K,
+                                            std::unique_ptr<MemoryBuffer> O) {
   auto &ES = L.getExecutionSession();
-  auto Obj = cantFail(
-      object::ObjectFile::createObjectFile(this->O->getMemBufferRef()));
+  auto Obj = object::ObjectFile::createObjectFile(O->getMemBufferRef());
+
+  if (!Obj)
+    return Obj.takeError();
 
-  for (auto &Sym : Obj->symbols()) {
+  SymbolFlagsMap SymbolFlags;
+  for (auto &Sym : (*Obj)->symbols()) {
     if (!(Sym.getFlags() & object::BasicSymbolRef::SF_Undefined) &&
          (Sym.getFlags() & object::BasicSymbolRef::SF_Exported)) {
       auto InternedName =
           ES.getSymbolStringPool().intern(cantFail(Sym.getName()));
-      SymbolFlags[InternedName] = JITSymbolFlags::fromObjectSymbol(Sym);
+      auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym);
+      if (!SymFlags)
+        return SymFlags.takeError();
+      SymbolFlags[InternedName] = std::move(*SymFlags);
     }
   }
+
+  return std::unique_ptr<BasicObjectLayerMaterializationUnit>(
+      new BasicObjectLayerMaterializationUnit(std::move(SymbolFlags), L, K,
+                                              std::move(O)));
 }
 
+BasicObjectLayerMaterializationUnit::BasicObjectLayerMaterializationUnit(
+    SymbolFlagsMap SymbolFlags, ObjectLayer &L, VModuleKey K,
+    std::unique_ptr<MemoryBuffer> O)
+    : MaterializationUnit(std::move(SymbolFlags)), L(L), K(std::move(K)),
+      O(std::move(O)) {}
+
 void BasicObjectLayerMaterializationUnit::materialize(
     MaterializationResponsibility R) {
   L.emit(std::move(R), std::move(K), std::move(O));