C++ Address::getAddress方法代码示例

/// Emit a call to do an 'initializeArrayWithTakeFrontToBack' operation.
void irgen::emitInitializeArrayWithTakeFrontToBackCall(IRGenFunction &IGF,
                                            SILType T,
                                            Address destObject,
                                            Address srcObject,
                                            llvm::Value *count) {
  auto metadata = IGF.emitTypeMetadataRefForLayout(T);
  llvm::Value *copyFn = IGF.emitValueWitnessForLayout(T,
                             ValueWitness::InitializeArrayWithTakeFrontToBack);
  llvm::CallInst *call =
    IGF.Builder.CreateCall(copyFn,
      {destObject.getAddress(), srcObject.getAddress(), count, metadata});
  call->setCallingConv(IGF.IGM.DefaultCC);
  call->setDoesNotThrow();
}

QByteArray Common::packAddress(const Address &addr)//pack a shadowsocks header
{
    QByteArray ss_header;
    QByteArray address_str = addr.getAddress().toLocal8Bit();
    QByteArray address_bin;
    quint16 port_net = htons(addr.getPort());
    QByteArray port_ns = QByteArray::fromRawData(reinterpret_cast<char *>(&port_net), 2);

    int type = addr.addressType();
    ss_header.append(static_cast<char>(type));
    switch (type) {
    case Address::ADDRTYPE_HOST://should we care if it exceeds 255?
        ss_header.append(static_cast<char>(address_str.length()));
        ss_header += address_str;
        break;
    case Address::ADDRTYPE_IPV4:
        address_bin.resize(INET_ADDRSTRLEN);
        inet_pton(AF_INET, address_str.constData(), reinterpret_cast<void *>(address_bin.data()));
        ss_header += address_bin;
        break;
    case Address::ADDRTYPE_IPV6:
        address_bin.resize(INET6_ADDRSTRLEN);
        inet_pton(AF_INET6, address_str.constData(), reinterpret_cast<void *>(address_bin.data()));
        ss_header += address_bin;
        break;
    }
    return ss_header + port_ns;
}

/// Emit a global variable.
Address IRGenModule::emitSILGlobalVariable(SILGlobalVariable *var) {
  auto &ti = getTypeInfo(var->getLoweredType());
  
  // If the variable is empty in all resilience domains, don't actually emit it;
  // just return undef.
  if (ti.isKnownEmpty(ResilienceExpansion::Minimal)) {
    if (DebugInfo && var->getDecl()) {
      auto Zero = llvm::ConstantInt::get(Int64Ty, 0);
      DebugTypeInfo DbgTy(var->getDecl(), var->getLoweredType().getSwiftType(),
                          Int8Ty, Size(0), Alignment(1));
      DebugInfo->emitGlobalVariableDeclaration(
          Zero, var->getDecl()->getName().str(), "", DbgTy,
          var->getLinkage() != SILLinkage::Public, SILLocation(var->getDecl()));
    }
    return ti.getUndefAddress();
  }

  /// Get the global variable.
  Address addr = getAddrOfSILGlobalVariable(var, ti,
                     var->isDefinition() ? ForDefinition : NotForDefinition);
  
  /// Add a zero initializer.
  if (var->isDefinition()) {
    auto gvar = cast<llvm::GlobalVariable>(addr.getAddress());
    gvar->setInitializer(llvm::Constant::getNullValue(gvar->getValueType()));
  }

  return addr;
}

/**
 * FUNCTION NAME: updateLeader
 *
 * DESCRIPTION: Update Leader information
 */
void Member::updateLeader(Address leaderAddr, std::string leaderName) {
    
    if (getLeaderAddress().compare(leaderAddr.getAddress()) == 0) return;
    std::cout << "NOTICE " << leaderEntry->getUsername() << " left the chat or crashed." << std::endl;
    std::string leader_ip_port = leaderAddr.getAddress();
    leaderEntry = new MemberListEntry(leader_ip_port, leaderName);
    
    std::cout << "NOTICE " << getLeaderName() << " is the new leader" << std::endl;
    // New leader should not be in the list
    deleteMember(leader_ip_port);
    
#ifdef DEBUGLOG
    std::cout << "\tNew Leader: " << getLeaderName() << std::endl;
#endif
    
}

llvm::Constant *IRGenModule::getOrCreateOutlinedDestroyFunction(
                              SILType T, const TypeInfo &ti,
                              const OutliningMetadataCollector &collector) {
  IRGenMangler mangler;
  auto manglingBits = getTypeAndGenericSignatureForManglingOutlineFunction(T);
  auto funcName = mangler.mangleOutlinedDestroyFunction(manglingBits.first,
                                                        manglingBits.second);

  auto ptrTy = ti.getStorageType()->getPointerTo();
  llvm::SmallVector<llvm::Type *, 4> paramTys;
  paramTys.push_back(ptrTy);
  collector.addMetadataParameterTypes(paramTys);

  return getOrCreateHelperFunction(funcName, ptrTy, paramTys,
      [&](IRGenFunction &IGF) {
        Explosion params = IGF.collectParameters();
        Address addr = ti.getAddressForPointer(params.claimNext());
        collector.bindMetadataParameters(IGF, params);

        ti.destroy(IGF, addr, T, true);
        
        IGF.Builder.CreateRet(addr.getAddress());
      },
      true /*setIsNoInline*/);
}

void TransactionSimicsProcessor::updateStoreSetPredictor(CacheRequestType type, Address address) {
  assert(XACT_EAGER_CD);      
  if(type == CacheRequestType_LD_XACT){
    m_xact_mgr->addToLoadAddressMap(0, SIMICS_get_program_counter(m_proc).getAddress(), address.getAddress());
  } else if (type == CacheRequestType_ST_XACT){
    m_xact_mgr->updateStorePredictor(0, address.getAddress());
  }
}

/// Emit a call to do a 'deallocateBuffer' operation.
void irgen::emitDeallocateBufferCall(IRGenFunction &IGF,
                                     llvm::Value *metadata,
                                     Address buffer) {
  auto fn = emitLoadOfValueWitnessFromMetadata(IGF, metadata,
                                   ValueWitness::DeallocateBuffer);
  llvm::CallInst *call =
    IGF.Builder.CreateCall(fn, {buffer.getAddress(), metadata});
  call->setCallingConv(IGF.IGM.DefaultCC);
  setHelperAttributes(call);
}

/// Emit a call to the 'destructiveProjectEnumData' operation.
/// The type must be dynamically known to have enum witnesses.
void irgen::emitDestructiveProjectEnumDataCall(IRGenFunction &IGF,
                                               SILType T,
                                               Address srcObject) {
  auto metadata = IGF.emitTypeMetadataRefForLayout(T);
  llvm::Value *fn = IGF.emitValueWitnessForLayout(T,
                                      ValueWitness::DestructiveProjectEnumData);
  llvm::CallInst *call =
    IGF.Builder.CreateCall(fn, {srcObject.getAddress(), metadata});
  call->setCallingConv(IGF.IGM.DefaultCC);
  setHelperAttributes(call);
}

bool Socket::send(const Address& receiver, const void* data, int size)
{
	sockaddr_in address;
	address.sin_family = AF_INET;
	address.sin_addr.S_un.S_addr = htonl(receiver.getAddress());
	address.sin_port = htons(receiver.getPort());

	//TODO handle partial packet sending through network
	int bytesSent = sendto(m_socketHandle, (const char*) data, size, 0, (const sockaddr*) &address, sizeof(sockaddr_in));

	return bytesSent == size;
}

/// Emit a call to do a 'destroyArray' operation.
void irgen::emitDestroyArrayCall(IRGenFunction &IGF,
                                 SILType T,
                                 Address object,
                                 llvm::Value *count) {
  auto metadata = IGF.emitTypeMetadataRefForLayout(T);
  llvm::Value *fn = IGF.emitValueWitnessForLayout(T,
                                   ValueWitness::DestroyArray);
  llvm::CallInst *call =
    IGF.Builder.CreateCall(fn, {object.getAddress(), count, metadata});
  call->setCallingConv(IGF.IGM.DefaultCC);
  setHelperAttributes(call);
}

// peer
void Connection::connect(Address addr)
{
	m_last_recieved = porting::getTimeMs();
	//MutexAutoLock peerlock(m_peers_mutex);
	//m_peers.lock_unique_rec();
	auto node = m_peers.find(PEER_ID_SERVER);
	if(node != m_peers.end()){
		//throw ConnectionException("Already connected to a server");
		ConnectionEvent ev(CONNEVENT_CONNECT_FAILED);
		putEvent(ev);
	}

	m_enet_host = enet_host_create(NULL, 1, 0, 0, 0);
	ENetAddress address;
#if defined(ENET_IPV6)
	if (!addr.isIPv6())
		inet_pton (AF_INET6, ("::ffff:"+addr.serializeString()).c_str(), &address.host);
	else
		address.host = addr.getAddress6().sin6_addr;
#else
	if (addr.isIPv6()) {
		//throw ConnectionException("Cant connect to ipv6 address");
		ConnectionEvent ev(CONNEVENT_CONNECT_FAILED);
		putEvent(ev);
	} else {
		address.host = addr.getAddress().sin_addr.s_addr;
	}
#endif

	address.port = addr.getPort();
	ENetPeer *peer = enet_host_connect(m_enet_host, &address, CHANNEL_COUNT, 0);
	peer->data = new u16;
	*((u16*)peer->data) = PEER_ID_SERVER;

	ENetEvent event;
	int ret = enet_host_service (m_enet_host, & event, 5000);
	if (ret > 0 && event.type == ENET_EVENT_TYPE_CONNECT) {
		m_peers.set(PEER_ID_SERVER, peer);
		m_peers_address.set(PEER_ID_SERVER, addr);
	} else {
		errorstream<<"connect enet_host_service ret="<<ret<<std::endl;
		if (ret == 0) {
			ConnectionEvent ev(CONNEVENT_CONNECT_FAILED);
			putEvent(ev);
		}

		/* Either the 5 seconds are up or a disconnect event was */
		/* received. Reset the peer in the event the 5 seconds   */
		/* had run out without any significant event.            */
		enet_peer_reset(peer);
	}
}

void MP1Node::handleFAILNotification(Address* a){
    vector<MemberListEntry>::iterator myPos;
    //Remove node with address of FAIL
    for (myPos = memberNode->memberList.begin();
        myPos != memberNode->memberList.end();
        ++myPos) {
	    Address nodeAddr = AddrUtils::initAddress(myPos->getid(), myPos->getport());
    	if (a->getAddress() == nodeAddr.getAddress()) {
    		removeMember(myPos);
    		return;
    	}
    }
}

/// Initialize a relative indirectable pointer to the given value.
/// This always leaves the value in the direct state; if it's not a
/// far reference, it's the caller's responsibility to ensure that the
/// pointer ranges are sufficient.
void IRGenFunction::emitStoreOfRelativeIndirectablePointer(llvm::Value *value,
                                                           Address addr,
                                                           bool isFar) {
  value = Builder.CreatePtrToInt(value, IGM.IntPtrTy);
  auto addrAsInt =
    Builder.CreatePtrToInt(addr.getAddress(), IGM.IntPtrTy);

  auto difference = Builder.CreateSub(value, addrAsInt);
  if (!isFar) {
    difference = Builder.CreateTrunc(difference, IGM.RelativeAddressTy);
  }

  Builder.CreateStore(difference, addr);
}

/// Emit a call to the 'destructiveInjectEnumTag' operation.
/// The type must be dynamically known to have enum witnesses.
void irgen::emitDestructiveInjectEnumTagCall(IRGenFunction &IGF,
                                             SILType T,
                                             unsigned tag,
                                             Address srcObject) {
  auto metadata = IGF.emitTypeMetadataRefForLayout(T);
  llvm::Value *fn = IGF.emitValueWitnessForLayout(T,
                                      ValueWitness::DestructiveInjectEnumTag);
  llvm::Value *tagValue =
    llvm::ConstantInt::get(IGF.IGM.Int32Ty, tag);
  llvm::CallInst *call =
    IGF.Builder.CreateCall(fn, {srcObject.getAddress(), tagValue, metadata});
  call->setCallingConv(IGF.IGM.DefaultCC);
  setHelperAttributes(call);
}

// host
void Connection::serve(Address bind_addr)
{
	ENetAddress address;
#if defined(ENET_IPV6)
	address.host = bind_addr.getAddress6().sin6_addr; // in6addr_any;
#else
	address.host = bind_addr.getAddress().sin_addr.s_addr; // ENET_HOST_ANY;
#endif
	address.port = bind_addr.getPort(); // fmtodo

	m_enet_host = enet_host_create(&address, g_settings->getU16("max_users"), CHANNEL_COUNT, 0, 0);
	if (m_enet_host == NULL) {
		ConnectionEvent ev(CONNEVENT_BIND_FAILED);
		putEvent(ev);
	}
}