void LuaStackFrame::resetPC() {
if(!isLua()) return;
code_ = getFunc()->getLClosure()->proto_->instructions_.begin();
constants_ = getFunc()->getLClosure()->proto_->constants.begin();
savedpc = -1;
}
LuaCallBase::LuaCallBase(lua_State *L, const char *func) : _L(L)
{
SLB_DEBUG_CALL;
lua_getglobal(L,func);
getFunc(-1);
lua_pop(L,1);
}
//功能：得到一条语句中的变量名,保存到数组中
//参数：begin指明从哪里开始查找函数
//返回值：变量名的个数
int getVarFromOneCmd(int begin, string cmd, string oneCmdVarName[])
{
int cmdVarLen = 0;
string func[255] = {""};
int flen = 0;
int rowNum = getFunc(func, begin, flen);
string funcVarName[255] = {""};
int vlen = 0;
vlen = getFuncVar(funcVarName, begin); // 得到函数的所有变量名
string globeVarName[255] = {""};
int glen = 0;
glen = getGlobeVar(globeVarName);
string single[255] = {""};
int slen = 0;
slen = covertCmd(cmd, single);
for(int i=0; i<slen; i++)
{
if(isIn(single[i], funcVarName, vlen) || isIn(single[i], globeVarName, glen)) // 如果single[i]是变量名
{
oneCmdVarName[cmdVarLen] = single[i];
cmdVarLen++;
}
}
return cmdVarLen;
}
/**********************
* Returns true if do array bounds checking for the current function
*/
bool IRState::arrayBoundsCheck()
{
bool result;
switch (global.params.useArrayBounds)
{
case BOUNDSCHECKoff:
result = false;
break;
case BOUNDSCHECKon:
result = true;
break;
case BOUNDSCHECKsafeonly:
{
result = false;
FuncDeclaration *fd = getFunc();
if (fd)
{ Type *t = fd->type;
if (t->ty == Tfunction && ((TypeFunction *)t)->trust == TRUSTsafe)
result = true;
}
break;
}
default:
assert(0);
}
return result;
}
unsigned int
ROEdge::getNumSuccessors() const {
if (getFunc() == ET_SINK) {
return 0;
}
return (unsigned int) myFollowingEdges.size();
}
void LuaStackFrame::sanityCheck() {
if(isLua()) {
LuaProto *p = getFunc()->getLClosure()->proto_;
assert(savedpc >= -1);
assert(savedpc < (int)p->instructions_.size());
}
}
/**
*@brief Pythonの関数実行の関数
* @param fname 関数名
*/
void PyObj::setFunc(const char *fname)
{
PyGILState_STATE gilstate;
gilstate = PyGILState_Ensure();
bpy::object pfunc = getFunc(fname);
try
{
pfunc();
}
catch(const bpy::error_already_set&)
{
PyErr_Print();
}
catch (...)
{
}
PyGILState_Release(gilstate);
}
unsigned int
ROEdge::getNumPredecessors() const {
if (getFunc() == ET_SOURCE) {
return 0;
}
return (unsigned int) myApproachingEdges.size();
}
int LuaStackFrame::getCurrentLine() {
if(!isLua()) return -1;
if(savedpc == -1) return -1;
LuaProto *p = getFunc()->getLClosure()->proto_;
return p->getLine( savedpc );
}
//功能：检查一个函数中的变量在使用前是否赋了初值,基本思想就是检查一个变量第一次出现时其后是否是"=", 是的话就不再检查，不是的话就检查它第二次出现时其后是否是等"="
//返回值：函数结尾下一行行数减1
int noInitialVarFunc(int begin)
{
int i, j, k;
string func[255] = {""};
int flen = 0;
int rowNum = getFunc(func, begin, flen);
if(-1 != rowNum)
{
string funcVarName[255] = {""};
int vlen = getFuncVar(funcVarName, begin);
string single[255] = {""};
int slen = 0;
int pos[10] = {-1};
int posCount = -1;
for(i=0; i<vlen; i++) // 要考虑一行中多次出现变量的情况，如for语句中
{
int tempFlag = -1; //变量是否赋值的标志
for(j=0; j<flen; j++)
{
tempFlag = -1;
slen = covertCmd(func[j], single);
posCount = isContain(funcVarName[i], single, slen, pos);
if(1 == posCount) // 变量在该行出现一次
{
if("=" == single[pos[0]+1]) // j行变量声明时赋值了，不需要再检查
{
break;
}
else // 变量声明时没有赋值，继续检查，下次出现时一定要赋值
{
for(k=j+1; k<flen; k++)
{
slen = covertCmd(func[k], single);
posCount = isContain(funcVarName[i], single, slen, pos);
if(-1 != posCount) // k行第二次出现变量
{
if("=" != single[pos[0]+1]) // 如果第二次没有赋值就报错
{
errNum[errLen] = (rowNum-flen+j+1);
errType[errLen] = 8;
errLen++;
}
tempFlag = 1;
break; //第二次出现了变量就跳出
}
}
}
if(1 == tempFlag)
break;
}
} //遍历命令
} //遍历变量名
}
return rowNum;
}
/**
* Convert a string representing a function into a function
*
* @param serialized A string representing a function
* @return The function represented by the string
*/
std::shared_ptr<TransformerFunction const> InverseOffsetFunction::deserialize(std::string const &serialized) {
std::stringstream ss(serialized);
std::string s;
std::getline(ss, s, ','); // sign
int sign = atoi(s.c_str());
std::getline(ss, s); // offset
int offset = atoi(s.c_str());
return getFunc(sign, offset);
} // deserialize
supla_channel_temphum *supla_device_channel::getTempHum(void) {
double temp;
if ( getType() == SUPLA_CHANNELTYPE_THERMOMETERDS18B20
&& getFunc() == SUPLA_CHANNELFNC_THERMOMETER ) {
getDouble(&temp);
if ( temp > -273 && temp <= 1000 ) {
return new supla_channel_temphum(0, getId(), temp, 0);
}
} else if ( ( getType() == SUPLA_CHANNELTYPE_DHT11
|| getType() == SUPLA_CHANNELTYPE_DHT22
|| getType() == SUPLA_CHANNELTYPE_AM2302 )
&& ( getFunc() == SUPLA_CHANNELFNC_THERMOMETER
|| getFunc() == SUPLA_CHANNELFNC_HUMIDITY
|| getFunc() == SUPLA_CHANNELFNC_HUMIDITYANDTEMPERATURE ) ) {
int n;
char value[SUPLA_CHANNELVALUE_SIZE];
double humidity;
getValue(value);
memcpy(&n, value, 4);
temp = n/1000.00;
memcpy(&n, &value[4], 4);
humidity = n/1000.00;
if ( temp > -273
&& temp <= 1000
&& humidity >= 0
&& humidity <= 100 ) {
return new supla_channel_temphum(1, getId(), temp, humidity);
}
}
return NULL;
}
//功能：检测一个函数中的内存泄漏问题 1.1、malloc开了内存，没有free这块内存。
int memoryLeakFunc1(int begin)
{
string func[255] = {""};
int flen = 0;
int rowNum = -1;
rowNum = getFunc(func, begin, flen);
if(-1 != rowNum) // 如果读取到了函数
{
int i, j;
string temp = "";
string single[255] = {""};
int slen = 0;
for(i=0; i<flen; i++)
{
temp = func[i];
slen = covertCmd(temp, single);
// 有"malloc"没有"="的情况
if(isIn("malloc", single, slen) && !isIn("=", single, slen))
{
errNum[errLen] = (rowNum-flen+i+1);
errType[errLen] = 7;
errLen++;
}
//有"malloc", 有"="的情况
if(isIn("malloc", single, slen) && isIn("=", single, slen))
{
int freeFlag = -1;
int pos[10] = {-1};
int posCount = -1;
posCount = isContain("=", single, slen, pos);
string pFree = single[pos[0]-1];
for(j=i+1; j<flen; j++)
{
temp = func[j];
slen = covertCmd(temp, single);
if(isIn("free", single, slen) && isIn(pFree, single, slen)) // free了pFree指向的指针
{
freeFlag = 1;
break;
}
}
if(-1 == freeFlag) // 如果没有free
{
errNum[errLen] = (rowNum-flen+i+1);
errType[errLen] = 7;
errLen++;
}
}
}
return rowNum;
}
return -1;
}
static void funcEnter(unsigned long tid,const char *name,unsigned long long addr) {
sContext *context = getCurrent(tid);
sFuncCall *call = getFunc(context->current,name,addr);
if(call == NULL)
context->current = append(context->current,name,addr);
else
context->current = call;
context->current->running = 1;
context->current->calls++;
context->layer++;
}
X86CompilerFuncDecl* X86Compiler::endFunc()
{
X86CompilerFuncDecl* func = getFunc();
ASMJIT_ASSERT(func != NULL);
bind(func->_exitLabel);
addItem(func->_end);
func->setFuncFlag(kFuncFlagIsFinished);
_func = NULL;
return func;
}
Error X86Compiler::setArg(uint32_t argIndex, const Var& var) {
X86FuncNode* func = getFunc();
if (func == NULL)
return kErrorInvalidArgument;
if (!isVarValid(var))
return kErrorInvalidState;
VarData* vd = getVd(var);
func->setArg(argIndex, vd);
return kErrorOk;
}
void X86Compiler::_emitReturn(const Operand* first, const Operand* second)
{
X86CompilerFuncDecl* func = getFunc();
if (func == NULL)
{
setError(kErrorNoFunction);
return;
}
X86CompilerFuncRet* ret = Compiler_newItem<X86CompilerFuncRet>(this, func, first, second);
if (ret == NULL)
{
setError(kErrorNoHeapMemory);
return;
}
addItem(ret);
}
HLSentinel* X86Compiler::endFunc() {
X86FuncNode* func = getFunc();
ASMJIT_ASSERT(func != NULL);
// Add local constant pool at the end of the function (if exist).
setCursor(func->getExitNode());
if (_localConstPoolLabel.isInitialized()) {
embedConstPool(_localConstPoolLabel, _localConstPool);
_localConstPoolLabel.reset();
_localConstPool.reset();
}
// Finalize.
func->addFuncFlags(kFuncFlagIsFinished);
_func = NULL;
setCursor(func->getEnd());
return func->getEnd();
}
X86CompilerFuncCall* X86Compiler::_emitCall(const Operand* o0)
{
X86CompilerFuncDecl* func = getFunc();
if (func == NULL)
{
setError(kErrorNoFunction);
return NULL;
}
X86CompilerFuncCall* call = Compiler_newItem<X86CompilerFuncCall>(this, func, o0);
if (call == NULL)
{
setError(kErrorNoHeapMemory);
return NULL;
}
addItem(call);
return call;
}
int main() {
int funcIndex, status;
params *arguments = malloc(sizeof(params));
bool newLineNeeded = { TRUE };
getStartupText();
while (TRUE) {
getMarker(&newLineNeeded);
newLineNeeded.x = TRUE;
if ((funcIndex = getFunc(getInput(SPACE_CHAR))) == INVALID_FUNCTION)
continue;
if ((status = getArgs(&(cmd[funcIndex].info), getInput(NEWLINE),
arguments)) != OK) {
continue;
}
if (cmd[funcIndex].ptr == &empty) { /* Doesn't create a new line after an empty command. */
newLineNeeded.x = FALSE;
continue;
}
(cmd[funcIndex].ptr)(arguments);
}/* End while */
return 0;
}
XmmVar X86Compiler::getXmmArg(uint32_t argIndex)
{
X86CompilerFuncDecl* func = getFunc();
XmmVar var;
if (func != NULL)
{
const X86FuncDecl* decl = func->getDecl();
if (argIndex < decl->getArgumentsCount())
{
X86CompilerVar* cv = func->getVar(argIndex);
var._var.id = cv->getId();
var._var.size = cv->getSize();
var._var.regCode = x86VarInfo[cv->getType()].getCode();
var._var.varType = cv->getType();
}
}
return var;
}
Error Context::livenessAnalysis() {
FuncNode* func = getFunc();
JumpNode* from = NULL;
Node* node = func->getEnd();
uint32_t bLen = static_cast<uint32_t>(
((_contextVd.getLength() + VarBits::kEntityBits - 1) / VarBits::kEntityBits));
LivenessTarget* ltCur = NULL;
LivenessTarget* ltUnused = NULL;
size_t varMapToVaListOffset = _varMapToVaListOffset;
// No variables.
if (bLen == 0)
return kErrorOk;
VarBits* bCur = newBits(bLen);
if (bCur == NULL)
goto _NoMemory;
// Allocate bits for code visited first time.
_OnVisit:
for (;;) {
if (node->hasLiveness()) {
if (bCur->_addBitsDelSource(node->getLiveness(), bCur, bLen))
goto _OnPatch;
else
goto _OnDone;
}
VarBits* bTmp = copyBits(bCur, bLen);
if (bTmp == NULL)
goto _NoMemory;
node->setLiveness(bTmp);
VarMap* map = node->getMap();
if (map != NULL) {
uint32_t vaCount = map->getVaCount();
VarAttr* vaList = reinterpret_cast<VarAttr*>(((uint8_t*)map) + varMapToVaListOffset);
for (uint32_t i = 0; i < vaCount; i++) {
VarAttr* va = &vaList[i];
VarData* vd = va->getVd();
uint32_t flags = va->getFlags();
uint32_t ctxId = vd->getContextId();
if ((flags & kVarAttrOutAll) && !(flags & kVarAttrInAll)) {
// Write-Only.
bTmp->setBit(ctxId);
bCur->delBit(ctxId);
}
else {
// Read-Only or Read/Write.
bTmp->setBit(ctxId);
bCur->setBit(ctxId);
}
}
}
if (node->getType() == kNodeTypeTarget)
goto _OnTarget;
if (node == func)
goto _OnDone;
ASMJIT_ASSERT(node->getPrev());
node = node->getPrev();
}
// Patch already generated liveness bits.
_OnPatch:
for (;;) {
ASMJIT_ASSERT(node->hasLiveness());
VarBits* bNode = node->getLiveness();
if (!bNode->_addBitsDelSource(bCur, bLen))
goto _OnDone;
if (node->getType() == kNodeTypeTarget)
goto _OnTarget;
if (node == func)
goto _OnDone;
node = node->getPrev();
}
_OnTarget:
if (static_cast<TargetNode*>(node)->getNumRefs() != 0) {
// Push a new LivenessTarget onto the stack if needed.
if (ltCur == NULL || ltCur->node != node) {
// Allocate a new LivenessTarget object (from pool or zone).
LivenessTarget* ltTmp = ltUnused;
if (ltTmp != NULL) {
ltUnused = ltUnused->prev;
}
else {
ltTmp = _baseZone.allocT<LivenessTarget>(
sizeof(LivenessTarget) - sizeof(VarBits) + bLen * sizeof(uintptr_t));
if (ltTmp == NULL)
goto _NoMemory;
}
// Initialize and make current - ltTmp->from will be set later on.
ltTmp->prev = ltCur;
ltTmp->node = static_cast<TargetNode*>(node);
ltCur = ltTmp;
from = static_cast<TargetNode*>(node)->getFrom();
ASMJIT_ASSERT(from != NULL);
}
else {
from = ltCur->from;
goto _OnJumpNext;
}
// Visit/Patch.
do {
ltCur->from = from;
bCur->copyBits(node->getLiveness(), bLen);
if (!from->hasLiveness()) {
node = from;
goto _OnVisit;
}
// Issue #25: Moved '_OnJumpNext' here since it's important to patch
// code again if there are more live variables than before.
_OnJumpNext:
if (bCur->delBits(from->getLiveness(), bLen)) {
node = from;
goto _OnPatch;
}
from = from->getJumpNext();
} while (from != NULL);
// Pop the current LivenessTarget from the stack.
{
LivenessTarget* ltTmp = ltCur;
ltCur = ltCur->prev;
ltTmp->prev = ltUnused;
ltUnused = ltTmp;
}
}
bCur->copyBits(node->getLiveness(), bLen);
node = node->getPrev();
if (node->isJmp() || !node->isFetched())
goto _OnDone;
if (!node->hasLiveness())
goto _OnVisit;
if (bCur->delBits(node->getLiveness(), bLen))
goto _OnPatch;
_OnDone:
if (ltCur != NULL) {
node = ltCur->node;
from = ltCur->from;
goto _OnJumpNext;
}
return kErrorOk;
_NoMemory:
return setError(kErrorNoHeapMemory);
}
void initGlobalFuncs(GlobalState& g) {
g.llvm_opaque_type = llvm::StructType::create(g.context, "opaque");
g.llvm_clfunction_type_ptr = lookupFunction("boxCLFunction")->arg_begin()->getType();
g.llvm_module_type_ptr = g.stdlib_module->getTypeByName("class.pyston::BoxedModule")->getPointerTo();
assert(g.llvm_module_type_ptr);
g.llvm_bool_type_ptr = lookupFunction("boxBool")->getReturnType();
g.llvm_value_type_ptr = lookupFunction("getattr")->getReturnType();
g.llvm_value_type = g.llvm_value_type_ptr->getSequentialElementType();
g.llvm_value_type_ptr_ptr = g.llvm_value_type_ptr->getPointerTo();
// g.llvm_class_type_ptr = llvm::cast<llvm::StructType>(g.llvm_value_type)->getElementType(0);
// g.llvm_class_type = g.llvm_class_type_ptr->getSequentialElementType();
g.llvm_class_type = g.stdlib_module->getTypeByName("class.pyston::BoxedClass");
assert(g.llvm_class_type);
g.llvm_class_type_ptr = g.llvm_class_type->getPointerTo();
g.llvm_str_type_ptr = lookupFunction("boxStringPtr")->arg_begin()->getType();
// The LLVM vector type for the arguments that we pass to runtimeCall and related functions.
// It will be a pointer to a type named something like class.std::vector or
// class.std::vector.##. We can figure out exactly what it is by looking at the last
// argument of runtimeCall.
g.vector_ptr = (--lookupFunction("runtimeCall")->getArgumentList().end())->getType();
g.llvm_closure_type_ptr = g.stdlib_module->getTypeByName("class.pyston::BoxedClosure")->getPointerTo();
assert(g.llvm_closure_type_ptr);
g.llvm_generator_type_ptr = g.stdlib_module->getTypeByName("class.pyston::BoxedGenerator")->getPointerTo();
assert(g.llvm_generator_type_ptr);
#define GET(N) g.funcs.N = getFunc((void*)N, STRINGIFY(N))
g.funcs.printf = addFunc((void*)printf, g.i8_ptr, true);
g.funcs.my_assert = getFunc((void*)my_assert, "my_assert");
g.funcs.malloc = addFunc((void*)malloc, g.i8_ptr, g.i64);
g.funcs.free = addFunc((void*)free, g.void_, g.i8_ptr);
g.funcs.allowGLReadPreemption = addFunc((void*)threading::allowGLReadPreemption, g.void_);
GET(boxCLFunction);
GET(unboxCLFunction);
GET(createUserClass);
GET(boxInt);
GET(unboxInt);
GET(boxFloat);
GET(unboxFloat);
GET(boxStringPtr);
GET(boxInstanceMethod);
GET(boxBool);
GET(unboxBool);
GET(createTuple);
GET(createList);
GET(createDict);
GET(createSlice);
GET(createClosure);
GET(createGenerator);
GET(createLong);
GET(createSet);
GET(getattr);
GET(setattr);
GET(delattr);
GET(getitem);
GET(setitem);
GET(delitem);
GET(getGlobal);
GET(delGlobal);
GET(binop);
GET(compare);
GET(augbinop);
GET(nonzero);
GET(print);
GET(unboxedLen);
GET(getclsattr);
GET(unaryop);
GET(import);
GET(importFrom);
GET(importStar);
GET(repr);
GET(isinstance);
GET(yield);
GET(checkUnpackingLength);
GET(raiseAttributeError);
GET(raiseAttributeErrorStr);
GET(raiseNotIterableError);
GET(assertNameDefined);
GET(assertFail);
GET(printFloat);
GET(listAppendInternal);
g.funcs.runtimeCall = getFunc((void*)runtimeCall, "runtimeCall");
g.funcs.runtimeCall0 = addFunc((void*)runtimeCall, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32);
g.funcs.runtimeCall1
= addFunc((void*)runtimeCall, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32, g.llvm_value_type_ptr);
g.funcs.runtimeCall2 = addFunc((void*)runtimeCall, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32,
g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.runtimeCall3 = addFunc((void*)runtimeCall, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32,
g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.callattr = getFunc((void*)callattr, "callattr");
g.funcs.callattr0
= addFunc((void*)callattr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_str_type_ptr, g.i1, g.i32);
g.funcs.callattr1 = addFunc((void*)callattr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_str_type_ptr,
g.i1, g.i32, g.llvm_value_type_ptr);
g.funcs.callattr2 = addFunc((void*)callattr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_str_type_ptr,
g.i1, g.i32, g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.callattr3 = addFunc((void*)callattr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_str_type_ptr,
g.i1, g.i32, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.reoptCompiledFunc = addFunc((void*)reoptCompiledFunc, g.i8_ptr, g.i8_ptr);
g.funcs.compilePartialFunc = addFunc((void*)compilePartialFunc, g.i8_ptr, g.i8_ptr);
GET(__cxa_begin_catch);
g.funcs.__cxa_end_catch = addFunc((void*)__cxa_end_catch, g.void_);
GET(raise0);
GET(raise3);
GET(div_float_float);
GET(mod_float_float);
GET(pow_float_float);
}
Automaton getAutomaton(int inputMemorySize, int outputMemorySize, int funcValuesAsInteger) {
BooleanFunction func = getFunc(1 + inputMemorySize + outputMemorySize, funcValuesAsInteger);
return AIOM(inputMemorySize, outputMemorySize, func).getAutomaton();
}
int ex(nodeType *p) {
int lblx, lbly, lbl1, lbl2, lblz, lbl3;
int i,j;
SymbolType type;
char* fun_name;
int numofparas;
FunNode* func;
nodeType* paras;
int *size;
if (!p) return 0;
switch(p->type) {
case typeCon:
printf("\tpush\t%d\n", p->con.value);
break;
case typeId:
printf("\tpush\tfp[%d]\n",getSymbol(p->id.i)->index);
break;
case typeStr:
printf("\tpush\t\"%s\"\n",p->str.value);// " not include in con.value
break;
case typeArr:
storeOffsetInIn(p);
testOutofBoundary(p);
printf("\tpush\tfp[in]\n");
break;
case typeOpr:
switch(p->opr.oper) {
case INT:
case CHAR://Declaration
if(p->opr.oper == INT)
type = INTTYPE;
else if(p->opr.oper == CHAR)
type = CHARTYPE;
else{
printf("Compile Error(1072): Unknown indentifier type\n");
exit(-1);
}
switch(p->opr.op[0]->type){
case typeId://A variable
printf("\tpush\tsp\n");//allocate space in stack
printf("\tpush\t1\n");
printf("\tadd\t\n");
printf("\tpop\tsp\n");
break;
case typeArr://An array
size = (int *)malloc(sizeof(int) * p->opr.op[0]->arr.dimension);
for(i = 0; i < p->opr.op[0]->arr.dimension; i++){
ex(p->opr.op[0]->arr.index[i]);
}
for(i = 0; i < p->opr.op[0]->arr.dimension - 1; i++){
printf("\tmul\t\n");
}
printf("\tpush\tsp\n");
printf("\tadd\t\n");
printf("\tpop\tsp\n");
break;
default:
printf("Compile Error(1070): Unknown declaration type. <%d>\n",p->opr.op[0]->type);
exit(-1);
break;
}
break;
case CODEBLOCK:
ex(p->opr.op[0]);
ex(p->opr.op[1]);
break;
case FOR:
ex(p->opr.op[0]);
printf("L%03d:\n", lblx = lbl++);
ex(p->opr.op[1]);
printf("\tj0\tL%03d\n", lbly = lbl++);
lblz = lbl++;
push(lblz,lbly);
ex(p->opr.op[3]);
printf("L%03d:\n", lblz);
ex(p->opr.op[2]);
printf("\tjmp\tL%03d\n", lblx);
printf("L%03d:\n", lbly);
pop();
break;
case CALL:
fun_name = p->opr.op[0]->id.i;//get function name;
numofparas = 0;
/*push parameters in stack*/
for(paras = p->opr.op[1];paras != NULL;paras = paras->para.next){
storeOffsetInIn(paras->para.name);
if(paras->para.name->type == typeArr)
testOutofBoundary(paras->para.name);
printf("\tpush\tfp[in]\n");//push para in stack
numofparas++;
}
/*actually, this exist check should be done in c8.y*/
if(func = getFunc(fun_name) == NULL){
printf("Error 1051: function (%s())not declared.\n",fun_name);
exit(-1);
}
printf("\tcall\tL%03d,%d\n",func->label,numofparas);
break;
case WHILE:
printf("L%03d:\n", lbl1 = lbl++);
ex(p->opr.op[0]);
printf("\tj0\tL%03d\n", lbl2 = lbl++);
push(lbl1,lbl2);
ex(p->opr.op[1]);
printf("\tjmp\tL%03d\n", lbl1);
printf("L%03d:\n", lbl2);
pop();
break;
case DO-WHILE:
lbl1 = lbl++;
lbl2 = lbl++;
lbl3 = lbl++;
push(lbl3,lbl2);
printf("L%03d:\n",lbl1);
ex(p->opr.op[0]);
printf("L%03d:\n", lbl3);
ex(p->opr.op[1]);
printf("\tj0\tL%03d\n", lbl2);
printf("\tjmp\tL%03d\n", lbl1);
printf("L%03d:\n", lbl2);
pop();
break;
case BREAK: printf("\tjmp\tL%03d\n", top(1)); break;
case CONTINUE: printf("\tjmp\tL%03d\n", top(0)); break;
case IF:
ex(p->opr.op[0]);
if (p->opr.nops > 2) {
printf("\tj0\tL%03d\n", lbl1 = lbl++);
ex(p->opr.op[1]);
printf("\tjmp\tL%03d\n", lbl2 = lbl++);
printf("L%03d:\n", lbl1);
ex(p->opr.op[2]);
printf("L%03d:\n", lbl2);
} else {
printf("\tj0\tL%03d\n", lbl1 = lbl++);
ex(p->opr.op[1]);
printf("L%03d:\n", lbl1);
}
break;
case READ:
printf("\tgeti\n");
storeOffsetInIn(p->opr.op[0]);
if(p->opr.op[0]->type == typeArr)
testOutofBoundary(p->opr.op[0]);
printf("\tpop\tfp[in]\n");
break;
case PRINT:
ex(p->opr.op[0]);
printf("\tputi\n");
break;
case '=':
ex(p->opr.op[1]);
storeOffsetInIn(p->opr.op[0]);
if(p->opr.op[0]->type == typeArr)
testOutofBoundary(p->opr.op[0]);
printf("\tpop\tfp[in]\n");
break;
case UMINUS:
ex(p->opr.op[0]);
printf("\tneg\n");
break;
default:/*Expr*/
/*semicolon*/
ex(p->opr.op[0]);
ex(p->opr.op[1]);
switch(p->opr.oper) {
case '+': printf("\tadd\n"); break;
case '-': printf("\tsub\n"); break;
case '*': printf("\tmul\n"); break;
case '/': printf("\tdiv\n"); break;
case '%': printf("\tmod\n"); break;
case '<': printf("\tcomplt\n"); break;
case '>': printf("\tcompgt\n"); break;
case GE: printf("\tcompge\n"); break;
case LE: printf("\tcomple\n"); break;
case NE: printf("\tcompne\n"); break;
case EQ: printf("\tcompeq\n"); break;
case AND: printf("\tand\n"); break;
case OR: printf("\tor\n"); break;
}
}
}
return 0;
}
void initGlobalFuncs(GlobalState& g) {
g.llvm_opaque_type = llvm::StructType::create(g.context, "opaque");
g.llvm_functionmetadata_type_ptr = lookupFunction("createFunctionFromMetadata")->arg_begin()->getType();
g.llvm_module_type_ptr = g.stdlib_module->getTypeByName("class.pyston::BoxedModule")->getPointerTo();
assert(g.llvm_module_type_ptr);
g.llvm_bool_type_ptr = lookupFunction("boxBool")->getReturnType();
g.llvm_value_type_ptr = lookupFunction("getattr")->getReturnType();
g.llvm_value_type = g.llvm_value_type_ptr->getSequentialElementType();
g.llvm_value_type_ptr_ptr = g.llvm_value_type_ptr->getPointerTo();
// g.llvm_class_type_ptr = llvm::cast<llvm::StructType>(g.llvm_value_type)->getElementType(0);
// g.llvm_class_type = g.llvm_class_type_ptr->getSequentialElementType();
g.llvm_class_type = g.stdlib_module->getTypeByName("class.pyston::BoxedClass");
assert(g.llvm_class_type);
g.llvm_class_type_ptr = g.llvm_class_type->getPointerTo();
g.llvm_boxedstring_type_ptr = g.stdlib_module->getTypeByName("class.pyston::BoxedString");
assert(g.llvm_boxedstring_type_ptr);
g.llvm_boxedstring_type_ptr = g.llvm_boxedstring_type_ptr->getPointerTo();
g.llvm_dict_type_ptr = g.stdlib_module->getTypeByName("class.pyston::BoxedDict");
assert(g.llvm_dict_type_ptr);
g.llvm_dict_type_ptr = g.llvm_dict_type_ptr->getPointerTo();
g.llvm_aststmt_type_ptr = g.stdlib_module->getTypeByName("class.pyston::AST_stmt");
assert(g.llvm_aststmt_type_ptr);
g.llvm_aststmt_type_ptr = g.llvm_aststmt_type_ptr->getPointerTo();
g.llvm_astexpr_type_ptr = g.stdlib_module->getTypeByName("class.pyston::AST_expr");
assert(g.llvm_astexpr_type_ptr);
g.llvm_astexpr_type_ptr = g.llvm_astexpr_type_ptr->getPointerTo();
// The LLVM vector type for the arguments that we pass to runtimeCall and related functions.
// It will be a pointer to a type named something like class.std::vector or
// class.std::vector.##. We can figure out exactly what it is by looking at the last
// argument of runtimeCall.
g.vector_ptr = (--lookupFunction("runtimeCall")->getArgumentList().end())->getType();
g.llvm_closure_type_ptr = g.stdlib_module->getTypeByName("class.pyston::BoxedClosure")->getPointerTo();
assert(g.llvm_closure_type_ptr);
g.llvm_generator_type_ptr = g.stdlib_module->getTypeByName("class.pyston::BoxedGenerator")->getPointerTo();
assert(g.llvm_generator_type_ptr);
g.llvm_excinfo_type = g.stdlib_module->getTypeByName("struct.pyston::ExcInfo");
assert(g.llvm_excinfo_type);
g.llvm_frame_info_type = g.stdlib_module->getTypeByName("struct.pyston::FrameInfo");
assert(g.llvm_frame_info_type);
#define GET(N) g.funcs.N = getFunc((void*)N, STRINGIFY(N))
g.funcs.printf = addFunc((void*)printf, g.i8_ptr, true);
g.funcs.my_assert = getFunc((void*)my_assert, "my_assert");
g.funcs.malloc = addFunc((void*)malloc, g.i8_ptr, g.i64);
g.funcs.free = addFunc((void*)free, g.void_, g.i8_ptr);
g.funcs.allowGLReadPreemption = getFunc((void*)threading::allowGLReadPreemption, "allowGLReadPreemption");
GET(softspace);
GET(createFunctionFromMetadata);
GET(getFunctionMetadata);
GET(createUserClass);
GET(boxInt);
GET(unboxInt);
GET(boxFloat);
GET(unboxFloat);
GET(boxInstanceMethod);
GET(boxBool);
GET(unboxBool);
GET(createTuple);
GET(createList);
GET(createDict);
GET(createSlice);
GET(createClosure);
GET(createGenerator);
GET(createSet);
GET(initFrame);
GET(deinitFrame);
GET(getattr);
GET(getattr_capi);
GET(setattr);
GET(delattr);
GET(getitem);
GET(getitem_capi);
GET(setitem);
GET(delitem);
GET(getGlobal);
GET(delGlobal);
GET(setGlobal);
GET(binop);
GET(compare);
GET(augbinop);
GET(nonzero);
GET(unboxedLen);
GET(getclsattr);
GET(unaryop);
GET(import);
GET(importFrom);
GET(importStar);
GET(repr);
GET(exceptionMatches);
GET(yield);
GET(getiterHelper);
GET(hasnext);
GET(apply_slice);
GET(unpackIntoArray);
GET(raiseAttributeError);
GET(raiseAttributeErrorStr);
GET(raiseAttributeErrorCapi);
GET(raiseAttributeErrorStrCapi);
GET(raiseIndexErrorStr);
GET(raiseIndexErrorStrCapi);
GET(raiseNotIterableError);
GET(assertNameDefined);
GET(assertFailDerefNameDefined);
GET(assertFail);
GET(printExprHelper);
GET(printHelper);
GET(listAppendInternal);
GET(getSysStdout);
GET(exec);
GET(boxedLocalsSet);
GET(boxedLocalsGet);
GET(boxedLocalsDel);
g.funcs.runtimeCall.cxx_val = getFunc((void*)runtimeCall, "runtimeCall");
g.funcs.runtimeCall0.cxx_val = addFunc((void*)runtimeCall, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32);
g.funcs.runtimeCall1.cxx_val
= addFunc((void*)runtimeCall, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32, g.llvm_value_type_ptr);
g.funcs.runtimeCall2.cxx_val = addFunc((void*)runtimeCall, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32,
g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.runtimeCall3.cxx_val = addFunc((void*)runtimeCall, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32,
g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.runtimeCallN.cxx_val
= addFunc((void*)runtimeCall, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32, g.llvm_value_type_ptr,
g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr->getPointerTo());
g.funcs.runtimeCall.capi_val = getFunc((void*)runtimeCallCapi, "runtimeCallCapi");
g.funcs.runtimeCall0.capi_val
= addFunc((void*)runtimeCallCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32);
g.funcs.runtimeCall1.capi_val
= addFunc((void*)runtimeCallCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32, g.llvm_value_type_ptr);
g.funcs.runtimeCall2.capi_val = addFunc((void*)runtimeCallCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32,
g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.runtimeCall3.capi_val = addFunc((void*)runtimeCallCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32,
g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.runtimeCallN.capi_val
= addFunc((void*)runtimeCallCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.i32, g.llvm_value_type_ptr,
g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr->getPointerTo());
g.funcs.callattr.cxx_val = getFunc((void*)callattr, "callattr");
g.funcs.callattr0.cxx_val
= addFunc((void*)callattr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_boxedstring_type_ptr, g.i64);
g.funcs.callattr1.cxx_val = addFunc((void*)callattr, g.llvm_value_type_ptr, g.llvm_value_type_ptr,
g.llvm_boxedstring_type_ptr, g.i64, g.llvm_value_type_ptr);
g.funcs.callattr2.cxx_val
= addFunc((void*)callattr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_boxedstring_type_ptr, g.i64,
g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.callattr3.cxx_val
= addFunc((void*)callattr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_boxedstring_type_ptr, g.i64,
g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.callattrN.cxx_val = addFunc(
(void*)callattr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_boxedstring_type_ptr, g.i64,
g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr->getPointerTo());
g.funcs.callattr.capi_val = getFunc((void*)callattrCapi, "callattrCapi");
g.funcs.callattr0.capi_val = addFunc((void*)callattrCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr,
g.llvm_boxedstring_type_ptr, g.i64);
g.funcs.callattr1.capi_val = addFunc((void*)callattrCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr,
g.llvm_boxedstring_type_ptr, g.i64, g.llvm_value_type_ptr);
g.funcs.callattr2.capi_val
= addFunc((void*)callattrCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_boxedstring_type_ptr, g.i64,
g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.callattr3.capi_val
= addFunc((void*)callattrCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_boxedstring_type_ptr, g.i64,
g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr);
g.funcs.callattrN.capi_val = addFunc(
(void*)callattrCapi, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_boxedstring_type_ptr, g.i64,
g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr, g.llvm_value_type_ptr->getPointerTo());
g.funcs.reoptCompiledFunc = addFunc((void*)reoptCompiledFunc, g.i8_ptr, g.i8_ptr);
g.funcs.compilePartialFunc = addFunc((void*)compilePartialFunc, g.i8_ptr, g.i8_ptr);
g.funcs.__cxa_end_catch = addFunc((void*)__cxa_end_catch, g.void_);
GET(raise0);
GET(raise0_capi);
GET(raise3);
GET(raise3_capi);
GET(PyErr_Fetch);
GET(PyErr_NormalizeException);
GET(PyErr_Restore);
GET(caughtCapiException);
GET(reraiseCapiExcAsCxx);
GET(deopt);
GET(div_float_float);
GET(floordiv_float_float);
GET(mod_float_float);
GET(pow_float_float);
GET(dump);
}
QString VDPAUContext::init()
{
QString err;
vdp_get_proc_address = NULL;
vdpDevice = VDP_INVALID_HANDLE;
VdpStatus st = vdp_device_create_x11( vdpDisplay, vdpScreen, &vdpDevice, &vdp_get_proc_address );
if ( st != VDP_STATUS_OK ) {
err = "Can't create vdp device : ";
if ( st == VDP_STATUS_NO_IMPLEMENTATION )
err += "No vdpau implementation.";
else
err += "Unsupported GPU?";
return err;
}
if ( vdpDevice==VDP_INVALID_HANDLE )
return "Invalid VdpDevice handle !!";
if ( !vdp_get_proc_address )
return "vdp_get_proc_address is NULL !!";
if ( !getFunc( VDP_FUNC_ID_GET_ERROR_STRING , (void**)&vdp_get_error_string ) )
return "Can't get VDP_FUNC_ID_GET_ERROR_STRING address !!";
if ( !getFunc( VDP_FUNC_ID_GET_API_VERSION , (void**)&vdp_get_api_version ) )
return "Can't get VDP_FUNC_ID_GET_API_VERSION address !!";
if ( !getFunc( VDP_FUNC_ID_GET_INFORMATION_STRING , (void**)&vdp_get_information_string ) )
return "Can't get VDP_FUNC_ID_GET_INFORMATION_STRING address !!";
if ( !getFunc( VDP_FUNC_ID_DEVICE_DESTROY , (void**)&vdp_device_destroy ) )
return "Can't get VDP_FUNC_ID_DEVICE_DESTROY address !!";
if ( !getFunc( VDP_FUNC_ID_GENERATE_CSC_MATRIX , (void**)&vdp_generate_csc_matrix ) )
return "Can't get VDP_FUNC_ID_GENERATE_CSC_MATRIX address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES , (void**)&vdp_video_surface_query_capabilities ) )
return "Can't get VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES , (void**)&vdp_video_surface_query_get_put_bits_y_cb_cr_capabilities ) )
return "Can't get VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_SURFACE_CREATE , (void**)&vdp_video_surface_create ) )
return "Can't get VDP_FUNC_ID_VIDEO_SURFACE_CREATE address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_SURFACE_DESTROY , (void**)&vdp_video_surface_destroy ) )
return "Can't get VDP_FUNC_ID_VIDEO_SURFACE_DESTROY address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS , (void**)&vdp_video_surface_get_parameters ) )
return "Can't get VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR , (void**)&vdp_video_surface_get_bits_y_cb_cr ) )
return "Can't get VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR , (void**)&vdp_video_surface_put_bits_y_cb_cr ) )
return "Can't get VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES , (void**)&vdp_output_surface_query_capabilities ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES , (void**)&vdp_output_surface_query_get_put_bits_native_capabilities ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES , (void**)&vdp_output_surface_query_put_bits_indexed_capabilities ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES , (void**)&vdp_output_surface_query_put_bits_y_cb_cr_capabilities ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_CREATE , (void**)&vdp_output_surface_create ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_CREATE address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY , (void**)&vdp_output_surface_destroy ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS , (void**)&vdp_output_surface_get_parameters ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE , (void**)&vdp_output_surface_get_bits_native ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE , (void**)&vdp_output_surface_put_bits_native ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED , (void**)&vdp_output_surface_put_bits_indexed ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR , (void**)&vdp_output_surface_put_bits_y_cb_cr ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR address !!";
if ( !getFunc( VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES , (void**)&vdp_bitmap_surface_query_capabilities ) )
return "Can't get VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES address !!";
if ( !getFunc( VDP_FUNC_ID_BITMAP_SURFACE_CREATE , (void**)&vdp_bitmap_surface_create ) )
return "Can't get VDP_FUNC_ID_BITMAP_SURFACE_CREATE address !!";
if ( !getFunc( VDP_FUNC_ID_BITMAP_SURFACE_DESTROY , (void**)&vdp_bitmap_surface_destroy ) )
return "Can't get VDP_FUNC_ID_BITMAP_SURFACE_DESTROY address !!";
if ( !getFunc( VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS , (void**)&vdp_bitmap_surface_get_parameters ) )
return "Can't get VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS address !!";
if ( !getFunc( VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE , (void**)&vdp_bitmap_surface_put_bits_native ) )
return "Can't get VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE , (void**)&vdp_output_surface_render_output_surface ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE address !!";
if ( !getFunc( VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE , (void**)&vdp_output_surface_render_bitmap_surface ) )
return "Can't get VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE address !!";
if ( !getFunc( VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES , (void**)&vdp_decoder_query_capabilities ) )
return "Can't get VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES address !!";
if ( !getFunc( VDP_FUNC_ID_DECODER_CREATE , (void**)&vdp_decoder_create ) )
return "Can't get VDP_FUNC_ID_DECODER_CREATE address !!";
if ( !getFunc( VDP_FUNC_ID_DECODER_DESTROY , (void**)&vdp_decoder_destroy ) )
return "Can't get VDP_FUNC_ID_DECODER_DESTROY address !!";
if ( !getFunc( VDP_FUNC_ID_DECODER_GET_PARAMETERS , (void**)&vdp_decoder_get_parameters ) )
return "Can't get VDP_FUNC_ID_DECODER_GET_PARAMETERS address !!";
if ( !getFunc( VDP_FUNC_ID_DECODER_RENDER , (void**)&vdp_decoder_render ) )
return "Can't get VDP_FUNC_ID_DECODER_RENDER address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT , (void**)&vdp_video_mixer_query_feature_support ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT , (void**)&vdp_video_mixer_query_parameter_support ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT , (void**)&vdp_video_mixer_query_attribute_support ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE , (void**)&vdp_video_mixer_query_parameter_value_range ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE , (void**)&vdp_video_mixer_query_attribute_value_range ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_CREATE , (void**)&vdp_video_mixer_create ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_CREATE address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES , (void**)&vdp_video_mixer_set_feature_enables ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES , (void**)&vdp_video_mixer_set_attribute_values ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT , (void**)&vdp_video_mixer_get_feature_support ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES , (void**)&vdp_video_mixer_get_feature_enables ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES , (void**)&vdp_video_mixer_get_parameter_values ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES , (void**)&vdp_video_mixer_get_attribute_values ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_DESTROY , (void**)&vdp_video_mixer_destroy ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_DESTROY address !!";
if ( !getFunc( VDP_FUNC_ID_VIDEO_MIXER_RENDER , (void**)&vdp_video_mixer_render ) )
return "Can't get VDP_FUNC_ID_VIDEO_MIXER_RENDER address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11 , (void**)&vdp_presentation_queue_target_create_x11 ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11 address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY , (void**)&vdp_presentation_queue_target_destroy ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE , (void**)&vdp_presentation_queue_create ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY , (void**)&vdp_presentation_queue_destroy ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR , (void**)&vdp_presentation_queue_set_background_color ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR , (void**)&vdp_presentation_queue_get_background_color ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME , (void**)&vdp_presentation_queue_get_time ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY , (void**)&vdp_presentation_queue_display ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE , (void**)&vdp_presentation_queue_block_until_surface_idle ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE address !!";
if ( !getFunc( VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS , (void**)&vdp_presentation_queue_query_surface_status ) )
return "Can't get VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS address !!";
if ( !getFunc( VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER , (void**)&vdp_preemption_callback_register ) )
return "Can't get VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER address !!";
unsigned int tmp;
vdp_get_api_version( &tmp );
context.append( QString("VDPAU API version : %1\n").arg(tmp) );
const char *s;
st = vdp_get_information_string( &s );
context.append( QString("VDPAU implementation : %1\n\n").arg(s) );
getDecoderCaps();
#ifdef VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1
vdp_video_mixer_query_feature_support( vdpDevice, VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1, &hqScaling );
#endif
return "";
}
//功能：在一个函数中检测无效的switch语句
//返回值：返回函数结尾下一行减1
int switchInfunc(int beginFunc)
{
string func[255] = {""};
int flen = 0;
int rowNum = getFunc(func, beginFunc, flen);
int i, j, k;
if(-1 != rowNum)
{
int useFlag = -1;
int varEqualNum = 0;
string switchValue = ""; // switch 的值
string temp = "";
string single[255] = {""};
int slen = 0;
string oneCmdVarName[255] = {""};
int oneCmdVarLen = 0;
string switchCmd[255] = {""};
int switchLen = 0;
int beginInfunc = 0;
int pos[10] = {-1};
int posCount = -1;
for(i=0; i<flen; i++)
{
temp = func[i];
slen = covertCmd(temp, single);
if(isIn("switch", single, slen)) //在函数第i行位置 检测到switch语句
{
beginInfunc = i;
int switchPos = getOneSwitch(func, flen, beginInfunc, switchCmd, switchLen); // 得到第一个switch语句
temp = switchCmd[0]; // switch
slen = covertCmd(temp, single);
oneCmdVarLen = getVarFromOneCmd(beginFunc, switchCmd[0], oneCmdVarName);// 得到switch中的变量名
if(1 == oneCmdVarLen) //switch中只有一个变量时
{
for(j=0; j<oneCmdVarLen; j++) // 遍历switch中所有变量
{
useFlag = -1;
varEqualNum = 0;
for(k=i-1; k>=0; k--) // 在switch语句之前进行检测变量的赋值情况
{
temp = func[k];
slen = covertCmd(temp, single);
posCount = isContain(oneCmdVarName[j], single, slen, pos);
int m = 0; // 变量在一行中出现的次数遍历
if(-1 != posCount) // 如果出现了变量, 检测最后出现变量的位置是不是a=1的简单形式
{
for(m=posCount-1; m>=0; m--) // 从一行最后开始遍历变量
{
//single[pos[m]+1] 变量后的第一个字符
if(">" == single[pos[m]+1] || "<" == single[pos[m]+1] || ">=" == single[pos[m]+1] ||
"<=" == single[pos[m]+1] || "!=" == single[pos[m]+1] || "+" == single[pos[m]+1] || "-" == single[pos[m]+1] ||
"*" == single[pos[m]+1] || "/" == single[pos[m]+1])
{
continue;
}
if("=" == single[pos[m]+1] && onlyNum(single[pos[m]+2])) // a = 数字 的情况
{
switchValue = single[pos[m]+2]; // 得到switch的值
varEqualNum = 1;
break;
}
else
{
varEqualNum = -1;
break;
}
}
if(1 == varEqualNum || -1 == varEqualNum) // 如果continue了就要继续找下一行，而不是退出for循环
break;
}
}
if(-1 == varEqualNum)
{
// 说明有变量会变
useFlag = 1;
break; // 不是无效分去
}
}
int defaultFlag = -1;
if(-1 == useFlag) // 说明一直没有变量变，无效分支
{
defaultFlag = -1;
for(k=0; k<switchLen; k++)
{
temp = switchCmd[k];
slen = covertCmd(temp, single);
if(isIn("case", single, slen)) // 出现case 分支
{
if(switchValue != single[1]) // 当这一行的case值不是switch的时候则报错
{
errNum[errLen] = (rowNum-flen+i+1+k);
errType[errLen] = 3;
errLen++;
}
else // case值是switch值时，说明default也要报错
defaultFlag = 1;
}
}
for(k=0; k<switchLen; k++)
{
temp = switchCmd[k];
slen = covertCmd(temp, single);
if(isIn("default", single, slen) && 1 == defaultFlag) // 出现case 分支
{
errNum[errLen] = (rowNum-flen+i+1+k);
errType[errLen] = 3;
errLen++;
}
}
}
}//switch中只有一个变量时
int defaultFlag = -1;
if(0 == oneCmdVarLen) // 说明switch里面没有变量
{
temp = switchCmd[0];
slen = covertCmd(temp, single);
if(onlyNum(single[2]) && ")" == single[3]) // switch(1) 的形式
{
switchValue = single[2];
defaultFlag = -1;
for(k=0; k<switchLen; k++)
{
temp = switchCmd[k];
slen = covertCmd(temp, single);
if(isIn("case", single, slen)) // 出现case 分支
{
if(switchValue != single[1]) // 当这一行的case值不是switch的时候则报错
{
errNum[errLen] = (rowNum-flen+i+1+k);
errType[errLen] = 3;
errLen++;
}
else // case值是switch值时，说明default也要报错
defaultFlag = 1;
}
}
for(k=0; k<switchLen; k++)
{
temp = switchCmd[k];
slen = covertCmd(temp, single);
if(isIn("default", single, slen) && 1 == defaultFlag) // 出现case 分支
{
errNum[errLen] = (rowNum-flen+i+1+k);
errType[errLen] = 3;
errLen++;
}
}
}
}
} // 检测到switch的位置
}
}
return rowNum;
}
X86CompilerVar* X86Compiler::_newVar(const char* name, uint32_t type, uint32_t size)
{
X86CompilerVar* var = reinterpret_cast<X86CompilerVar*>(_zoneMemory.alloc(sizeof(X86CompilerVar)));
if (var == NULL) return NULL;
char nameBuffer[32];
if (name == NULL)
{
sprintf(nameBuffer, "var_%d", _varNameId);
name = nameBuffer;
_varNameId++;
}
var->_name = _zoneMemory.sdup(name);
var->_id = static_cast<uint32_t>(_vars.getLength()) | kOperandIdTypeVar;
var->_type = static_cast<uint8_t>(type);
var->_class = x86VarInfo[type].getClass();
var->_priority = 10;
var->_isRegArgument = false;
var->_isMemArgument = false;
var->_isCalculated = false;
var->_unused = 0;
var->_size = size;
var->firstItem = NULL;
var->lastItem = NULL;
var->funcScope = getFunc();
var->funcCall = NULL;
var->homeRegisterIndex = kRegIndexInvalid;
var->prefRegisterMask = 0;
var->homeMemoryOffset = 0;
var->homeMemoryData = NULL;
var->regIndex = kRegIndexInvalid;
var->workOffset = kInvalidValue;
var->nextActive = NULL;
var->prevActive = NULL;
var->state = kVarStateUnused;
var->changed = false;
var->saveOnUnuse = false;
var->regReadCount = 0;
var->regWriteCount = 0;
var->regRwCount = 0;
var->regGpbLoCount = 0;
var->regGpbHiCount = 0;
var->memReadCount = 0;
var->memWriteCount = 0;
var->memRwCount = 0;
var->tPtr = NULL;
_vars.append(var);
return var;
}
//功能：情况三考虑在一个函数中的情况，判断思想是找到if语句中所有的变量名，然后在if语句之前往上查找，如果最后一次出现该变量时是
//+"a=常数"的情况，如果最后是"a>、<、>=、<=、!=、+、-、*、/"的情况就跳过继续往上查，则判断为该变量是不变的，不过这样会有很多的bug，待解决啊……
int ifFunc3(int begin)
{
string func[255] = {""};
int flen = 0;
int rowNum = getFunc(func, begin, flen);
int i, j, k;
if(-1 != rowNum)
{
int varEqualNum = 0;
int useFlag = -1;
string single[255] = {""};
int slen = 0;
string temp = "";
string oneCmdVarName[255] = {""};
int cmdVarLen = 0;
int pos[10] = {-1};
int posCount = -1;
for(i=0; i<flen; i++)
{
temp = func[i];
slen = covertCmd(temp, single);
if(isIn("if", single, slen)) // 在func[i]中检测到if语句
{
cmdVarLen = getVarFromOneCmd(begin, temp, oneCmdVarName); // 得到if条件中变量名
for(j=0; j<cmdVarLen; j++) // 遍历if中所有变量
{
useFlag = -1;
varEqualNum = 0;
for(k=i-1; k>=0; k--) // 在if语句之前进行检测变量的赋值情况
{
temp = func[k];
slen = covertCmd(temp, single);
posCount = isContain(oneCmdVarName[j], single, slen, pos);
int m = 0; // 变量在一行中出现的次数遍历
if(-1 != posCount) // 如果出现了变量, 检测最后出现变量的位置是不是a=1的简单形式
{
for(m=posCount-1; m>=0; m--) // 从一行最后开始遍历变量
{
//single[pos[m]+1] 变量后的第一个字符
if(">" == single[pos[m]+1] || "<" == single[pos[m]+1] || ">=" == single[pos[m]+1] ||
"<=" == single[pos[m]+1] || "!=" == single[pos[m]+1] || "+" == single[pos[m]+1] || "-" == single[pos[m]+1] ||
"*" == single[pos[m]+1] || "/" == single[pos[m]+1])
{
continue;
}
if("=" == single[pos[m]+1] && onlyNum(single[pos[m]+2])) // a = 数字 的情况
{
varEqualNum = 1;
break;
}
else
{
varEqualNum = -1;
break;
}
}
if(1 == varEqualNum || -1 == varEqualNum) // 如果continue了就要继续找下一行，而不是退出for循环
break;
}
}
if(-1 == varEqualNum)
{
// 说明有变量会变
useFlag = 1;
break; // 不是无效分去
}
}
if(-1 == useFlag) // 说明一直没有变量变，无效分支
{
errNum[errLen] = rowNum-flen+i+1;
errType[errLen] = 3;
errLen++;
}
}
}
}
return rowNum;
}
