// See the file "COPYING" in the main distribution directory for copyright.

// Methods for dealing with variables (both ZAM and script-level).

#include "zeek/Desc.h"

#include "zeek/Reporter.h"

#include "zeek/script_opt/ZAM/Compile.h"

namespace zeek::detail {

bool ZAMCompiler::IsUnused(const IDPtr& id, const Stmt* where) const {

    if ( ! ud->HasUsage(where) )

        return true;

    auto usage = ud->GetUsage(where);

    // "usage" can be nil if due to constant propagation we've prune

    // all of the uses of the given identifier.

    return ! usage || ! usage->HasID(id.get());

}

bool ZAMCompiler::IsCapture(const ID* id) const {

    const auto& c = pf->CapturesOffsets();

    return c.find(id) != c.end();

}

int ZAMCompiler::CaptureOffset(const ID* id) const {

    auto id_offset = pf->CapturesOffsets().find(id);

    ASSERT(id_offset != pf->CapturesOffsets().end());

    return id_offset->second;

}

void ZAMCompiler::LoadParam(const ID* id) {

    if ( id->IsType() )

        reporter->InternalError("don't know how to compile local variable that's a type not a value");

    bool is_any = IsAny(id->GetType());

    ZOp op;

    op = AssignmentFlavor(OP_LOAD_VAL_Vi, id->GetType()->Tag());

    int slot = AddToFrame(id);

    ZInstI z(op, slot, id->Offset());

    z.SetType(id->GetType());

    z.op_type = OP_VV_FRAME;

    (void)AddInst(z);

}

const ZAMStmt ZAMCompiler::LoadGlobal(const ID* id) {

    ZOp op;

    if ( id->IsType() )

        // Need a special load for these, as they don't fit

        // with the usual template.

        op = OP_LOAD_GLOBAL_TYPE_Vg;

    else

        op = AssignmentFlavor(OP_LOAD_GLOBAL_Vg, id->GetType()->Tag());

    auto slot = RawSlot(id);

    ZInstI z(op, slot, global_id_to_info[id]);

    z.SetType(id->GetType());

    z.op_type = OP_VV_I2;

    // We use the id_val for reporting used-but-not-set errors.

    z.aux = new ZInstAux(0);

    z.aux->id_val = {NewRef{}, const_cast<ID*>(id)};

    return AddInst(z, true);

}

const ZAMStmt ZAMCompiler::LoadCapture(const ID* id) {

    ZOp op;

    if ( ZVal::IsManagedType(id->GetType()) )

        op = OP_LOAD_MANAGED_CAPTURE_Vi;

    else

        op = OP_LOAD_CAPTURE_Vi;

    auto slot = RawSlot(id);

    ZInstI z(op, slot, CaptureOffset(id));

    z.SetType(id->GetType());

    z.op_type = OP_VV_I2;

    return AddInst(z, true);

}

int ZAMCompiler::AddToFrame(const ID* id) {

    frame_layout1[id] = frame_sizeI;

    frame_denizens.push_back(id);

    return frame_sizeI++;

}

int ZAMCompiler::FrameSlot(const ID* id) {

    auto slot = RawSlot(id);

    if ( id->IsGlobal() )

        (void)LoadGlobal(id);

    else if ( IsCapture(id) )

        (void)LoadCapture(id);

    return slot;

}

int ZAMCompiler::Frame1Slot(const ID* id, ZAMOp1Flavor fl) {

    if ( fl == OP1_READ )

        return FrameSlot(id);

    if ( fl == OP1_INTERNAL )

        return RawSlot(id);

    ASSERT(fl == OP1_WRITE || fl == OP1_READ_WRITE);

    // Important: get the slot *before* tracking non-locals, so we don't

    // prematurely generate a Store for the read/write case.

    auto slot = fl == OP1_READ_WRITE ? FrameSlot(id) : RawSlot(id);

    if ( id->IsGlobal() )

        pending_global_store = global_id_to_info[id];

    else if ( IsCapture(id) )

        pending_capture_store = CaptureOffset(id);

    // Make sure we don't think we're storing to both a global and

    // a capture.

    ASSERT(pending_global_store == -1 || pending_capture_store == -1);

    return slot;

}

int ZAMCompiler::RawSlot(const ID* id) {

    auto id_slot = frame_layout1.find(id);

    if ( id_slot == frame_layout1.end() )

        reporter->InternalError("ID %s missing from frame layout", id->Name());

    return id_slot->second;

}

bool ZAMCompiler::HasFrameSlot(const ID* id) const { return frame_layout1.find(id) != frame_layout1.end(); }

int ZAMCompiler::NewSlot(bool is_managed) {

    char buf[8192];

    snprintf(buf, sizeof buf, "#internal-%d#", frame_sizeI);

    // In the following, all that matters is that for managed types

    // we pick a tag that will be viewed as managed, and vice versa.

    auto tag = is_managed ? TYPE_TABLE : TYPE_VOID;

    auto internal_reg = new ID(buf, SCOPE_FUNCTION, false);

    internal_reg->SetType(base_type(tag));

    return AddToFrame(internal_reg);

}

int ZAMCompiler::TempForConst(const ConstExpr* c) {

    auto slot = NewSlot(c->GetType());

    auto z = ZInstI(OP_ASSIGN_CONST_VC, slot, c);

    z.CheckIfManaged(c->GetType());

    (void)AddInst(z);

    return slot;

}

} // namespace zeek::detail