/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ECMASCRIPT_COMPILER_LLVM_CODEGEN_H
#define ECMASCRIPT_COMPILER_LLVM_CODEGEN_H

#include "ecmascript/compiler/binary_section.h"
#include "ecmascript/compiler/code_generator.h"

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow"
#pragma clang diagnostic ignored "-Wunused-parameter"
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#elif defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif

#include "llvm-c/Core.h"
#include "llvm-c/ExecutionEngine.h"
#include "llvm/ExecutionEngine/JITEventListener.h"

#if defined(__clang__)
#pragma clang diagnostic pop
#elif defined(__GNUC__)
#pragma GCC diagnostic pop
#endif

namespace panda::ecmascript::kungfu {
class CompilerLog;
class MethodLogList;
class LLVMModule;

enum class FPFlag : uint32_t {
    ELIM_FP = 0,
    RESERVE_FP = 1
};

struct LOptions {
    uint32_t optLevel : 2; // 2 bits for optimized level 0-4
    uint32_t genFp : 1; // 1 bit for whether to generated frame pointer or not
    uint32_t relocMode : 3; // 3 bits for relocation mode
    // 3: default optLevel, 1: generating fp, 2: PIC mode
    LOptions() : optLevel(3), genFp(static_cast<uint32_t>(FPFlag::RESERVE_FP)), relocMode(2) {};
    LOptions(size_t level, FPFlag flag, size_t relocMode)
        : optLevel(level), genFp(static_cast<uint32_t>(flag)), relocMode(relocMode) {};
};

class LLVMAssembler : public Assembler {
public:
    explicit LLVMAssembler(LLVMModule *lm, CodeInfo::CodeSpaceOnDemand &codeSpaceOnDemand,
                           LOptions option = LOptions(), bool isStubCompiler = false);
    virtual ~LLVMAssembler();
    void Run(const CompilerLog &log, bool fastCompileMode, bool isJit = false) override;
    const LLVMExecutionEngineRef &GetEngine()
    {
        return engine_;
    }
    void Disassemble(const std::map<uintptr_t, std::string> &addr2name, uint64_t textOffset,
                     const CompilerLog &log, const MethodLogList &logList, std::ostringstream &codeStream) const;
    static void Disassemble(const std::map<uintptr_t, std::string> *addr2name,
                            const std::string& triple, uint8_t *buf, size_t size);
    static int GetFpDeltaPrevFramSp(LLVMValueRef fn, const CompilerLog &log);
    static kungfu::CalleeRegAndOffsetVec GetCalleeReg2Offset(LLVMValueRef fn, const CompilerLog &log);

    void *GetFuncPtrFromCompiledModule(LLVMValueRef function)
    {
        return LLVMGetPointerToGlobal(engine_, function);
    }

    void SetObjFile(const llvm::object::ObjectFile *obj)
    {
        objFile_ = obj;
    }
private:
    class AOTEventListener : public llvm::JITEventListener {
      public:
        AOTEventListener(LLVMAssembler* as) : as_(as)
        {
        }
        void notifyObjectLoaded([[maybe_unused]] ObjectKey key, const llvm::object::ObjectFile &objFile,
                                [[maybe_unused]] const llvm::RuntimeDyld::LoadedObjectInfo &objInfo)
        {
            as_->SetObjFile(&objFile);
        }
      private:
        LLVMAssembler* GetAssembler() const
        {
            return as_;
        }

        LLVMAssembler* as_ {nullptr};
    };

    void UseRoundTripSectionMemoryManager(bool isJit);
    bool BuildMCJITEngine();
    void BuildAndRunPasses();
    void BuildAndRunPassesFastMode();
    void Initialize(LOptions option);
    static void PrintInstAndStep(uint64_t &pc, uint8_t **byteSp, uintptr_t &numBytes, size_t instSize,
                                 uint64_t textOffset, char *outString, std::ostringstream &codeStream,
                                 bool logFlag = true);
    uint64_t GetTextSectionIndex() const;

    LLVMMCJITCompilerOptions options_ {};
    LLVMModule *llvmModule_ {nullptr};
    LLVMModuleRef module_ {nullptr};
    const llvm::object::ObjectFile* objFile_ {nullptr};
    LLVMExecutionEngineRef engine_ {nullptr};
    AOTEventListener listener_;
    char *error_ {nullptr};
};

class LLVMIRGeneratorImpl : public CodeGeneratorImpl {
public:
    LLVMIRGeneratorImpl(LLVMModule *module, bool enableLog)
        : module_(module), enableLog_(enableLog) {}
    ~LLVMIRGeneratorImpl() override = default;
    void GenerateCodeForStub(Circuit *circuit, const ControlFlowGraph &graph, size_t index,
                             const CompilationConfig *cfg) override;
    void GenerateCode(Circuit *circuit, const ControlFlowGraph &graph, const CompilationConfig *cfg,
        const MethodLiteral *methodLiteral, const JSPandaFile *jsPandaFile, const std::string &methodName,
        const FrameType frameType, bool enableOptInlining, bool enableBranchProfiling) override;

    bool IsLogEnabled() const
    {
        return enableLog_;
    }

private:
    LLVMModule *module_;
    bool enableLog_ {false};
};
}  // namespace panda::ecmascript::kungfu
#endif  // ECMASCRIPT_COMPILER_LLVM_CODEGEN_H