File: ExtensionFuncResolution.cpp

package info (click to toggle)
intel-graphics-compiler 1.0.12504.6-1%2Bdeb12u1
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 83,912 kB
  • sloc: cpp: 910,147; lisp: 202,655; ansic: 15,197; python: 4,025; yacc: 2,241; lex: 1,570; pascal: 244; sh: 104; makefile: 25
file content (121 lines) | stat: -rw-r--r-- 4,320 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
/*========================== begin_copyright_notice ============================

Copyright (C) 2017-2022 Intel Corporation

SPDX-License-Identifier: MIT

============================= end_copyright_notice ===========================*/

#include "Compiler/Optimizer/OpenCLPasses/ExtensionFuncs/ExtensionFuncResolution.hpp"
#include "Compiler/Optimizer/OpenCLPasses/ExtensionFuncs/ExtensionFuncsAnalysis.hpp"
#include "Compiler/IGCPassSupport.h"
#include "common/LLVMWarningsPush.hpp"
#include <llvmWrapper/IR/IRBuilder.h>
#include <llvm/IR/Function.h>
#include <llvm/IR/Instructions.h>
#include "common/LLVMWarningsPop.hpp"
#include "Probe/Assertion.h"

using namespace llvm;
using namespace IGC;

// Register pass to igc-opt
#define PASS_FLAG "igc-extension-funcs-resolution"
#define PASS_DESCRIPTION "Resolves extension function"
#define PASS_CFG_ONLY false
#define PASS_ANALYSIS false
IGC_INITIALIZE_PASS_BEGIN(ExtensionFuncsResolution, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)
IGC_INITIALIZE_PASS_DEPENDENCY(MetaDataUtilsWrapper)
IGC_INITIALIZE_PASS_DEPENDENCY(CodeGenContextWrapper)
IGC_INITIALIZE_PASS_END(ExtensionFuncsResolution, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)

char ExtensionFuncsResolution::ID = 0;

ExtensionFuncsResolution::ExtensionFuncsResolution() : FunctionPass(ID), m_implicitArgs()
{
    initializeExtensionFuncsResolutionPass(*PassRegistry::getPassRegistry());
}

bool ExtensionFuncsResolution::runOnFunction(Function& F)
{
    m_changed = false;
    m_implicitArgs = ImplicitArgs(F, getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils());
    visit(F);
    return m_changed;
}

void ExtensionFuncsResolution::visitCallInst(CallInst& CI)
{
    if (!CI.getCalledFunction())
    {
        return;
    }

    StringRef funcName = CI.getCalledFunction()->getName();
    Function& F = *(CI.getParent()->getParent());

    ImplicitArg::ArgType argType;
    if (funcName.equals(ExtensionFuncsAnalysis::VME_MB_BLOCK_TYPE))
    {
        argType = ImplicitArg::VME_MB_BLOCK_TYPE;
    }
    else if (funcName.equals(ExtensionFuncsAnalysis::VME_SUBPIXEL_MODE))
    {
        argType = ImplicitArg::VME_SUBPIXEL_MODE;
    }
    else if (funcName.equals(ExtensionFuncsAnalysis::VME_SAD_ADJUST_MODE))
    {
        argType = ImplicitArg::VME_SAD_ADJUST_MODE;
    }
    else if (funcName.equals(ExtensionFuncsAnalysis::VME_SEARCH_PATH_TYPE))
    {
        argType = ImplicitArg::VME_SEARCH_PATH_TYPE;
    }
    else if (funcName.startswith(ExtensionFuncsAnalysis::VME_HELPER_GET_HANDLE)) {
        // Load from the opaque vme pointer and return the a vector with values.
        IGC_ASSERT(IGCLLVM::getNumArgOperands(&CI) == 1);
        IGCLLVM::IRBuilder<> builder(&CI);
        Type* retType = CI.getType();
        IGC_ASSERT(retType->isVectorTy() || retType->isIntegerTy());
        PointerType* ptrType = PointerType::get(retType, 0);
        auto bitcastInst = builder.CreateBitCast(CI.getArgOperand(0), ptrType);
        auto ret = builder.CreateLoad(bitcastInst);
        CI.replaceAllUsesWith(ret);
        CI.eraseFromParent();
        return;
    }
    else if (funcName.startswith(ExtensionFuncsAnalysis::VME_HELPER_GET_AS)) {
        // Store the VME values and return an opaque vme pointer.
        IGC_ASSERT(IGCLLVM::getNumArgOperands(&CI) == 1);
        IGCLLVM::IRBuilder<> builder(&*CI.getParent()->getParent()->begin()->getFirstInsertionPt());
        Type* retType = CI.getType();
        Value* arg = CI.getArgOperand(0);
        IGC_ASSERT(arg->getType()->isVectorTy() || arg->getType()->isIntegerTy());
        AllocaInst* allocaInst = builder.CreateAlloca(arg->getType());
        builder.SetInsertPoint(&CI);
        builder.CreateStore(arg, allocaInst);
        Value* bitcastInst = builder.CreateBitCast(allocaInst, retType);
        CI.replaceAllUsesWith(bitcastInst);
        CI.eraseFromParent();
        return;
    }
    else {
        // Non VME function, do nothing
        return;
    }

    Value* vmeRes = m_implicitArgs.getImplicitArg(F, argType);

    // Replace original VME call instruction with the appropriate argument, example:

    // Recieves:
    // call i32 @__builtin_IB_vme_subpixel_mode()

    // Creates:
    // %vmeSubpixelMode

    CI.replaceAllUsesWith(vmeRes);
    CI.eraseFromParent();

    m_changed = true;
}