void Client::SendGuildMOTD(bool GetGuildMOTDReply) {
auto outapp = new EQApplicationPacket(OP_GuildMOTD, sizeof(GuildMOTD_Struct));
// When the Client gets an OP_GuildMOTD, it compares the text to the version it has previously stored.
// If the text in the OP_GuildMOTD packet is the same, it does nothing. If not the same, it displays
// the new MOTD and then stores the new text.
//
// When the Client receives an OP_GetGuildMOTDReply, it displays the text in the packet.
//
// So OP_GuildMOTD should be sent on zone entry and when an Officer changes the MOTD, and OP_GetGuildMOTDReply
// should be sent when the client issues the /getguildmotd command.
//
if(GetGuildMOTDReply)
outapp->SetOpcode(OP_GetGuildMOTDReply);
GuildMOTD_Struct *motd = (GuildMOTD_Struct *) outapp->pBuffer;
motd->unknown0 = 0;
strn0cpy(motd->name, m_pp.name, 64);
if(IsInAGuild()) {
if(!guild_mgr.GetGuildMOTD(GuildID(), motd->motd, motd->setby_name)) {
motd->setby_name[0] = '\0';
strcpy(motd->motd, "ERROR GETTING MOTD!");
}
} else {
//we have to send them an empty MOTD anywyas.
motd->motd[0] = '\0'; //just to be sure
motd->setby_name[0] = '\0'; //just to be sure
}
Log(Logs::Detail, Logs::Guilds, "Sending OP_GuildMOTD of length %d", outapp->size);
FastQueuePacket(&outapp);
}
//! Compresses another packet and stores it in self (source left intact)
void WorldPacket::Compress(z_stream* compressionStream, WorldPacket const* source)
{
ASSERT(source != this);
Opcodes uncompressedOpcode = source->GetOpcode();
if (uncompressedOpcode & COMPRESSED_OPCODE_MASK)
{
sLog->outError(LOG_FILTER_NETWORKIO, "Packet with opcode 0x%04X is already compressed!", uncompressedOpcode);
return;
}
Opcodes opcode = Opcodes(uncompressedOpcode | COMPRESSED_OPCODE_MASK);
uint32 size = source->size();
uint32 destsize = compressBound(size);
size_t sizePos = 0;
resize(destsize + sizeof(uint32));
_compressionStream = compressionStream;
Compress(static_cast<void*>(&_storage[0] + sizeof(uint32)), &destsize, static_cast<const void*>(source->contents()), size);
if (destsize == 0)
return;
put<uint32>(sizePos, size);
resize(destsize + sizeof(uint32));
SetOpcode(opcode);
sLog->outInfo(LOG_FILTER_NETWORKIO, "%s (len %u) successfully compressed to %04X (len %u)", GetOpcodeNameForLogging(uncompressedOpcode, true).c_str(), size, opcode, destsize);
}
//! Compresses packet in place
void WorldPacket::Compress(z_stream* compressionStream)
{
Opcodes uncompressedOpcode = GetOpcode();
if (uncompressedOpcode & COMPRESSED_OPCODE_MASK)
{
sLog->outError(LOG_FILTER_NETWORKIO, "Packet with opcode 0x%04X is already compressed!", uncompressedOpcode);
return;
}
Opcodes opcode = Opcodes(uncompressedOpcode | COMPRESSED_OPCODE_MASK);
uint32 size = wpos();
uint32 destsize = compressBound(size);
std::vector<uint8> storage(destsize);
_compressionStream = compressionStream;
Compress(static_cast<void*>(&storage[0]), &destsize, static_cast<const void*>(contents()), size);
if (destsize == 0)
return;
clear();
reserve(destsize + sizeof(uint32));
*this << uint32(size);
append(&storage[0], destsize);
SetOpcode(opcode);
sLog->outInfo(LOG_FILTER_NETWORKIO, "%s (len %u) successfully compressed to %04X (len %u)", GetOpcodeNameForLogging(uncompressedOpcode, true).c_str(), size, opcode, destsize);
}
INetPacket * INetPacket::UnPackPacket()
{
NetPacketHeader Header;
_Read( (uint8*)&Header,PACKET_HEADER_SIZE);
//Header.size = BITSWAP16(Header.size );
Header.cmd = _BITSWAP16(Header.cmd );
//uint16 size = Header.size - PACKET_HEADER_SIZE;
SetOpcode(Header.cmd);
//_Read(r->GetWriteBuffer(size), size);
return this;
};
void Corpse::EndLoot(Client* client, const EQApplicationPacket* app) {
auto outapp = new EQApplicationPacket;
outapp->SetOpcode(OP_LootComplete);
outapp->size = 0;
client->QueuePacket(outapp);
safe_delete(outapp);
this->being_looted_by = 0xFFFFFFFF;
if (this->IsEmpty())
Delete();
else
Save();
}
void WorldPacket::compress(uint32 opcode)
{
if (opcode == OPCODE_NOT_FOUND) // this just doesn't look right, atm not using that define opcode way.
return;
uint32 uncompressedOpcode = GetOpcode();
uint32 size = wpos();
uint32 destsize = compressBound(size);
std::vector<uint8> storage(destsize);
_compress(static_cast<void*>(&storage[0]), &destsize, static_cast<const void*>(contents()), size);
if (destsize == 0)
return;
clear();
reserve(destsize + sizeof(uint32));
*this << uint32(size);
append(&storage[0], destsize);
SetOpcode(opcode);
sLog->outStaticDebug("Successfully compressed opcode %u (len %u) to %u (len %u)",
uncompressedOpcode, size, opcode, destsize);
}
void WorldPacket::compress(Opcodes opcode)
{
if (opcode == UNKNOWN_OPCODE)
return;
Opcodes uncompressedOpcode = GetOpcode();
uint32 size = wpos();
uint32 destsize = compressBound(size);
std::vector<uint8> storage(destsize);
_compress(static_cast<void*>(&storage[0]), &destsize, static_cast<const void*>(contents()), size);
if (destsize == 0)
return;
clear();
reserve(destsize + sizeof(uint32));
*this << uint32(size);
append(&storage[0], destsize);
SetOpcode(opcode);
sLog->outStaticDebug("Successfully compressed opcode %u (len %u) to %u (len %u)",
uncompressedOpcode, size, opcode, destsize);
}
PerlPacket::PerlPacket(const char *opcode, uint32 length) {
SetOpcode(opcode);
packet = NULL;
len = 0;
Resize(length);
}
bool AggressiveDCEPass::AggressiveDCE(Function* func) {
// Mark function parameters as live.
AddToWorklist(&func->DefInst());
func->ForEachParam(
[this](const Instruction* param) {
AddToWorklist(const_cast<Instruction*>(param));
},
false);
// Compute map from block to controlling conditional branch
std::list<BasicBlock*> structuredOrder;
cfg()->ComputeStructuredOrder(func, &*func->begin(), &structuredOrder);
ComputeBlock2HeaderMaps(structuredOrder);
bool modified = false;
// Add instructions with external side effects to worklist. Also add branches
// EXCEPT those immediately contained in an "if" selection construct or a loop
// or continue construct.
// TODO(greg-lunarg): Handle Frexp, Modf more optimally
call_in_func_ = false;
func_is_entry_point_ = false;
private_stores_.clear();
// Stacks to keep track of when we are inside an if- or loop-construct.
// When immediately inside an if- or loop-construct, we do not initially
// mark branches live. All other branches must be marked live.
std::stack<bool> assume_branches_live;
std::stack<uint32_t> currentMergeBlockId;
// Push sentinel values on stack for when outside of any control flow.
assume_branches_live.push(true);
currentMergeBlockId.push(0);
for (auto bi = structuredOrder.begin(); bi != structuredOrder.end(); ++bi) {
// If exiting if or loop, update stacks
if ((*bi)->id() == currentMergeBlockId.top()) {
assume_branches_live.pop();
currentMergeBlockId.pop();
}
for (auto ii = (*bi)->begin(); ii != (*bi)->end(); ++ii) {
SpvOp op = ii->opcode();
switch (op) {
case SpvOpStore: {
uint32_t varId;
(void)GetPtr(&*ii, &varId);
// Mark stores as live if their variable is not function scope
// and is not private scope. Remember private stores for possible
// later inclusion. We cannot call IsLocalVar at this point because
// private_like_local_ has not been set yet.
if (IsVarOfStorage(varId, SpvStorageClassPrivate) ||
IsVarOfStorage(varId, SpvStorageClassWorkgroup))
private_stores_.push_back(&*ii);
else if (!IsVarOfStorage(varId, SpvStorageClassFunction))
AddToWorklist(&*ii);
} break;
case SpvOpCopyMemory:
case SpvOpCopyMemorySized: {
uint32_t varId;
(void)GetPtr(ii->GetSingleWordInOperand(kCopyMemoryTargetAddrInIdx),
&varId);
if (IsVarOfStorage(varId, SpvStorageClassPrivate) ||
IsVarOfStorage(varId, SpvStorageClassWorkgroup))
private_stores_.push_back(&*ii);
else if (!IsVarOfStorage(varId, SpvStorageClassFunction))
AddToWorklist(&*ii);
} break;
case SpvOpLoopMerge: {
assume_branches_live.push(false);
currentMergeBlockId.push(
ii->GetSingleWordInOperand(kLoopMergeMergeBlockIdInIdx));
} break;
case SpvOpSelectionMerge: {
assume_branches_live.push(false);
currentMergeBlockId.push(
ii->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx));
} break;
case SpvOpSwitch:
case SpvOpBranch:
case SpvOpBranchConditional:
case SpvOpUnreachable: {
if (assume_branches_live.top()) {
AddToWorklist(&*ii);
}
} break;
default: {
// Function calls, atomics, function params, function returns, etc.
// TODO(greg-lunarg): function calls live only if write to non-local
if (!ii->IsOpcodeSafeToDelete()) {
AddToWorklist(&*ii);
}
// Remember function calls
if (op == SpvOpFunctionCall) call_in_func_ = true;
} break;
}
}
}
// See if current function is an entry point
for (auto& ei : get_module()->entry_points()) {
if (ei.GetSingleWordInOperand(kEntryPointFunctionIdInIdx) ==
func->result_id()) {
func_is_entry_point_ = true;
break;
}
}
// If the current function is an entry point and has no function calls,
// we can optimize private variables as locals
private_like_local_ = func_is_entry_point_ && !call_in_func_;
// If privates are not like local, add their stores to worklist
if (!private_like_local_)
for (auto& ps : private_stores_) AddToWorklist(ps);
// Perform closure on live instruction set.
while (!worklist_.empty()) {
Instruction* liveInst = worklist_.front();
// Add all operand instructions if not already live
liveInst->ForEachInId([&liveInst, this](const uint32_t* iid) {
Instruction* inInst = get_def_use_mgr()->GetDef(*iid);
// Do not add label if an operand of a branch. This is not needed
// as part of live code discovery and can create false live code,
// for example, the branch to a header of a loop.
if (inInst->opcode() == SpvOpLabel && liveInst->IsBranch()) return;
AddToWorklist(inInst);
});
if (liveInst->type_id() != 0) {
AddToWorklist(get_def_use_mgr()->GetDef(liveInst->type_id()));
}
// If in a structured if or loop construct, add the controlling
// conditional branch and its merge.
BasicBlock* blk = context()->get_instr_block(liveInst);
Instruction* branchInst = block2headerBranch_[blk];
if (branchInst != nullptr) {
AddToWorklist(branchInst);
Instruction* mergeInst = branch2merge_[branchInst];
AddToWorklist(mergeInst);
}
// If the block is a header, add the next outermost controlling
// conditional branch and its merge.
Instruction* nextBranchInst = header2nextHeaderBranch_[blk];
if (nextBranchInst != nullptr) {
AddToWorklist(nextBranchInst);
Instruction* mergeInst = branch2merge_[nextBranchInst];
AddToWorklist(mergeInst);
}
// If local load, add all variable's stores if variable not already live
if (liveInst->opcode() == SpvOpLoad || liveInst->IsAtomicWithLoad()) {
uint32_t varId;
(void)GetPtr(liveInst, &varId);
if (varId != 0) {
ProcessLoad(varId);
}
// Process memory copies like loads
} else if (liveInst->opcode() == SpvOpCopyMemory ||
liveInst->opcode() == SpvOpCopyMemorySized) {
uint32_t varId;
(void)GetPtr(liveInst->GetSingleWordInOperand(kCopyMemorySourceAddrInIdx),
&varId);
if (varId != 0) {
ProcessLoad(varId);
}
// If merge, add other branches that are part of its control structure
} else if (liveInst->opcode() == SpvOpLoopMerge ||
liveInst->opcode() == SpvOpSelectionMerge) {
AddBreaksAndContinuesToWorklist(liveInst);
// If function call, treat as if it loads from all pointer arguments
} else if (liveInst->opcode() == SpvOpFunctionCall) {
liveInst->ForEachInId([this](const uint32_t* iid) {
// Skip non-ptr args
if (!IsPtr(*iid)) return;
uint32_t varId;
(void)GetPtr(*iid, &varId);
ProcessLoad(varId);
});
// If function parameter, treat as if it's result id is loaded from
} else if (liveInst->opcode() == SpvOpFunctionParameter) {
ProcessLoad(liveInst->result_id());
// We treat an OpImageTexelPointer as a load of the pointer, and
// that value is manipulated to get the result.
} else if (liveInst->opcode() == SpvOpImageTexelPointer) {
uint32_t varId;
(void)GetPtr(liveInst, &varId);
if (varId != 0) {
ProcessLoad(varId);
}
}
worklist_.pop();
}
// Kill dead instructions and remember dead blocks
for (auto bi = structuredOrder.begin(); bi != structuredOrder.end();) {
uint32_t mergeBlockId = 0;
(*bi)->ForEachInst([this, &modified, &mergeBlockId](Instruction* inst) {
if (!IsDead(inst)) return;
if (inst->opcode() == SpvOpLabel) return;
// If dead instruction is selection merge, remember merge block
// for new branch at end of block
if (inst->opcode() == SpvOpSelectionMerge ||
inst->opcode() == SpvOpLoopMerge)
mergeBlockId = inst->GetSingleWordInOperand(0);
to_kill_.push_back(inst);
modified = true;
});
// If a structured if or loop was deleted, add a branch to its merge
// block, and traverse to the merge block and continue processing there.
// We know the block still exists because the label is not deleted.
if (mergeBlockId != 0) {
AddBranch(mergeBlockId, *bi);
for (++bi; (*bi)->id() != mergeBlockId; ++bi) {
}
auto merge_terminator = (*bi)->terminator();
if (merge_terminator->opcode() == SpvOpUnreachable) {
// The merge was unreachable. This is undefined behaviour so just
// return (or return an undef). Then mark the new return as live.
auto func_ret_type_inst = get_def_use_mgr()->GetDef(func->type_id());
if (func_ret_type_inst->opcode() == SpvOpTypeVoid) {
merge_terminator->SetOpcode(SpvOpReturn);
} else {
// Find an undef for the return value and make sure it gets kept by
// the pass.
auto undef_id = Type2Undef(func->type_id());
auto undef = get_def_use_mgr()->GetDef(undef_id);
live_insts_.Set(undef->unique_id());
merge_terminator->SetOpcode(SpvOpReturnValue);
merge_terminator->SetInOperands({{SPV_OPERAND_TYPE_ID, {undef_id}}});
get_def_use_mgr()->AnalyzeInstUse(merge_terminator);
}
live_insts_.Set(merge_terminator->unique_id());
}
} else {
++bi;
}
}
return modified;
}
IMG_INTERNAL
IMG_VOID ChangeProgramStructToExecPred(PINTERMEDIATE_STATE psState)
{
USC_LIST sFuncLoopsInfoLst;
FindProgramLoops(psState, &sFuncLoopsInfoLst);
RestructureProgramLoopsToExecPred(psState, &sFuncLoopsInfoLst);
FreeFuncLoopsInfoList(psState, &sFuncLoopsInfoLst);
if (psState->uExecPredTemp != USC_UNDEF)
{
PINST psInst = AllocateInst(psState, IMG_NULL);
SetOpcode(psState, psInst, IMOV);
SetDest(psState, psInst, 0 /* uDestIdx */, USEASM_REGTYPE_TEMP, psState->uExecPredTemp, UF_REGFORMAT_F32);
SetSrc(psState, psInst, 0, USEASM_REGTYPE_IMMEDIATE, 0, UF_REGFORMAT_F32);
InsertInstBefore(psState, psState->psMainProg->sCfg.psEntry,
psInst,
psState->psMainProg->sCfg.psEntry->psBody);
{
SAFE_LIST_ITERATOR sIter;
InstListIteratorInitialize(psState, ICNDSM, &sIter);
for (; InstListIteratorContinue(&sIter); InstListIteratorNext(&sIter))
{
PINST psCndsmInst;
IMG_UINT32 uAdjust;
psCndsmInst = InstListIteratorCurrent(&sIter);
uAdjust = psCndsmInst->asArg[3].uNumber;
if (AddStaticSecAttr(psState, uAdjust, NULL /* puArgType */, NULL /* puArgNum */))
{
IMG_UINT32 uArgType, uArgNumber;
/*
Use the secondary attribute as the instruction source.
*/
AddStaticSecAttr(psState, uAdjust, &uArgType, &uArgNumber);
SetSrc(psState, psCndsmInst, 3, uArgType, uArgNumber, UF_REGFORMAT_F32);
}
else
{
PINST psLimmInst;
IMG_UINT32 uImmTemp = GetNextRegister(psState);
PCODEBLOCK psLimmCodeBlock = AllocateBlock(psState, psCndsmInst->psBlock->psOwner);
RedirectEdgesFromPredecessors(psState, psCndsmInst->psBlock, psLimmCodeBlock, IMG_FALSE);
SetBlockUnconditional(psState, psLimmCodeBlock, psCndsmInst->psBlock);
/*
Add a LIMM instruction to load the immediate value into a temporary register.
*/
psLimmInst = AllocateInst(psState, psCndsmInst);
SetOpcode(psState, psLimmInst, ILIMM);
SetDestTempArg(psState, psLimmInst, 0 /* uDestIdx */, uImmTemp, UF_REGFORMAT_F32);
psLimmInst->asArg[0].uType = USEASM_REGTYPE_IMMEDIATE;
psLimmInst->asArg[0].uNumber = uAdjust;
InsertInstBefore(psState, psLimmCodeBlock, psLimmInst, psLimmCodeBlock->psBody);
/*
Use the temporary register as the instruction source.
*/
SetSourceTempArg(psState, psCndsmInst, 3, uImmTemp, UF_REGFORMAT_F32);
}
}
InstListIteratorFinalise(&sIter);
}
}
return;
}
