EchoServer(std::string const& locAddr, std::string const& port, unsigned threadsCount)
: Acceptor(IoService)
, Threads(threadsCount)
{
boost::asio::ip::tcp::resolver Resolver(IoService);
boost::asio::ip::tcp::resolver::query Query(locAddr, port);
boost::asio::ip::tcp::endpoint Endpoint = *Resolver.resolve(Query);
Acceptor.open(Endpoint.protocol());
Acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
Acceptor.bind(Endpoint);
Acceptor.listen();
StartAccept();
std::generate(Threads.begin(), Threads.end(),
boost::bind(
&boost::make_shared<boost::thread, boost::function<void ()> const &>,
boost::function<void ()>(boost::bind(&boost::asio::io_service::run, &IoService))
));
}
void PeerSocket::NewData()
{
int x,y;
do{
temp_array+=client->readAll();
}while(client->bytesAvailable());
while(1)
{
x=temp_array.indexOf(kStart);
if(x==-1)
{
break;
}
y=temp_array.indexOf(kEnd,x+2);
if(y==-1)
break;
Resolver(temp_array.mid(x,y-x+1));
temp_array.remove(x,y-x+1);
}
}
void RTDyldObjectLinkingLayer::emit(MaterializationResponsibility R,
std::unique_ptr<MemoryBuffer> O) {
assert(O && "Object must not be null");
// This method launches an asynchronous link step that will fulfill our
// materialization responsibility. We need to switch R to be heap
// allocated before that happens so it can live as long as the asynchronous
// link needs it to (i.e. it must be able to outlive this method).
auto SharedR = std::make_shared<MaterializationResponsibility>(std::move(R));
auto &ES = getExecutionSession();
// Create a MemoryBufferRef backed MemoryBuffer (i.e. shallow) copy of the
// the underlying buffer to pass into RuntimeDyld. This allows us to hold
// ownership of the real underlying buffer and return it to the user once
// the object has been emitted.
auto ObjBuffer = MemoryBuffer::getMemBuffer(O->getMemBufferRef(), false);
auto Obj = object::ObjectFile::createObjectFile(*ObjBuffer);
if (!Obj) {
getExecutionSession().reportError(Obj.takeError());
SharedR->failMaterialization();
return;
}
// Collect the internal symbols from the object file: We will need to
// filter these later.
auto InternalSymbols = std::make_shared<std::set<StringRef>>();
{
for (auto &Sym : (*Obj)->symbols()) {
if (!(Sym.getFlags() & object::BasicSymbolRef::SF_Global)) {
if (auto SymName = Sym.getName())
InternalSymbols->insert(*SymName);
else {
ES.reportError(SymName.takeError());
R.failMaterialization();
return;
}
}
}
}
auto K = R.getVModuleKey();
RuntimeDyld::MemoryManager *MemMgr = nullptr;
// Create a record a memory manager for this object.
{
auto Tmp = GetMemoryManager();
std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
MemMgrs.push_back(std::move(Tmp));
MemMgr = MemMgrs.back().get();
}
JITDylibSearchOrderResolver Resolver(*SharedR);
// FIXME: Switch to move-capture for the 'O' buffer once we have c++14.
MemoryBuffer *UnownedObjBuffer = O.release();
jitLinkForORC(
**Obj, std::move(O), *MemMgr, Resolver, ProcessAllSections,
[this, K, SharedR, &Obj, InternalSymbols](
std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
std::map<StringRef, JITEvaluatedSymbol> ResolvedSymbols) {
return onObjLoad(K, *SharedR, **Obj, std::move(LoadedObjInfo),
ResolvedSymbols, *InternalSymbols);
},
[this, K, SharedR, UnownedObjBuffer](Error Err) {
std::unique_ptr<MemoryBuffer> ObjBuffer(UnownedObjBuffer);
onObjEmit(K, std::move(ObjBuffer), *SharedR, std::move(Err));
});
}
