void CGUIDialogSmartPlaylistEditor::OnInitWindow() { m_cancelled = false; SendMessage(GUI_MSG_ITEM_SELECT, CONTROL_LIMIT, m_playlist.m_limit); std::vector<PLAYLIST_TYPE> allowedTypes; if (m_mode == "partymusic") { allowedTypes.push_back(TYPE_SONGS); allowedTypes.push_back(TYPE_MIXED); } else if (m_mode == "partyvideo") { allowedTypes.push_back(TYPE_MUSICVIDEOS); allowedTypes.push_back(TYPE_MIXED); } else if (m_mode == "music") { // music types + mixed allowedTypes.push_back(TYPE_SONGS); allowedTypes.push_back(TYPE_ALBUMS); allowedTypes.push_back(TYPE_ARTISTS); allowedTypes.push_back(TYPE_MIXED); } else if (m_mode == "video") { // general category for videos allowedTypes.push_back(TYPE_MOVIES); allowedTypes.push_back(TYPE_TVSHOWS); allowedTypes.push_back(TYPE_EPISODES); allowedTypes.push_back(TYPE_MUSICVIDEOS); allowedTypes.push_back(TYPE_MIXED); } // add to the spinner std::vector< std::pair<std::string, int> > labels; for (unsigned int i = 0; i < allowedTypes.size(); i++) labels.push_back(make_pair(GetLocalizedType(allowedTypes[i]), allowedTypes[i])); // check our playlist type is allowed PLAYLIST_TYPE type = ConvertType(m_playlist.GetType()); bool allowed = false; for (unsigned int i = 0; i < allowedTypes.size(); i++) if (type == allowedTypes[i]) allowed = true; if (!allowed && allowedTypes.size()) type = allowedTypes[0]; SET_CONTROL_LABELS(CONTROL_TYPE, type, &labels); m_playlist.SetType(ConvertType(type)); UpdateButtons(); SET_CONTROL_LABEL(CONTROL_HEADING, 21432); CGUIDialog::OnInitWindow(); }
void MAP_PlaceObjects(Map *map, char *fileName) { int x, y; // Object's coordinates from file char type; // Object's type from tile int total = 0; // Total of objects placed FILE *f; f = fopen(fileName, "r"); if(f == NULL){ printf("ERROR: File not found.\n"); } int mapColumns = map->width; while(fscanf(f, "%d %d %c\n", &y, &x, &type) == 3) { /*printf("Place object type %c on (%d, %d)\n", type, x, y);*/ // If this position is grass... if(map->positions[y * mapColumns + x].terrain == MAP_TileGrass) { // If position is empty, no restrictions if(map->positions[y * mapColumns + x].numObjs == 0) { map->positions[y * mapColumns + x].objs[0] = ConvertType(type); map->positions[y * mapColumns + x].numObjs++; total++; } // If position is occupied... else { // ... check if the combination of objects is possible bool allow = true; for(int k = 0; k < map->positions[y * mapColumns + x].numObjs; k++) { if(!AllowObjectsCombination(map->positions[y * mapColumns + x].objs[k], ConvertType(type))) { allow = false; } } if(allow) { map->positions[y * mapColumns + x].objs[map->positions[y * mapColumns + x].numObjs + 1] = ConvertType(type); map->positions[y * mapColumns + x].numObjs++; total++; } } } } printf("Total of objects placed: %d\n", total); fclose(f); }
/* Target hook for llvm-abi.h. It returns true if an aggregate of the specified type should be passed in a number of registers of mixed types. It also returns a vector of types that correspond to the registers used for parameter passing. */ bool llvm_rs6000_should_pass_aggregate_in_mixed_regs(tree TreeType, const Type* Ty, std::vector<const Type*>&Elts) { // FIXME there are plenty of ppc64 cases that need this. if (TARGET_64BIT) return false; // If this is a small fixed size type, investigate it. HOST_WIDE_INT SrcSize = int_size_in_bytes(TreeType); if (SrcSize <= 0 || SrcSize > 16) return false; const StructType *STy = dyn_cast<StructType>(Ty); if (!STy) return false; // A struct containing only a float, double or Altivec field, possibly with // some zero-length fields as well, must be passed as the field type. // Note this does not apply to long double, nor generic vectors. // Other single-element structs may be passed this way as well, but // only if the type size matches the element's type size (structs that // violate this can be created with __aligned__). tree tType = isSingleElementStructOrArray(TreeType, true, false); if (tType && int_size_in_bytes(tType)==SrcSize && TYPE_MODE(tType)!=TFmode && (TREE_CODE(tType)!=VECTOR_TYPE || SrcSize==16)) { Elts.push_back(ConvertType(tType)); return true; } Elts.clear(); return false; }
llvm::Function* WasmImportFunction::GetFunction(WasmModule* module) { if (function_ == nullptr) { // This probably should be done better but will work like this for now. std::string full_name = module_name_ + "_" + function_name_; // Now what we really want is the parameters of this method. std::vector<llvm::Type*> params; Populate(params); // Add to the name the type of the arguments for the import. // Again, probably not what we want finally but this will work. // My problem right now is how to handle the variadic functions well. for (auto elem : params) { full_name += "_"; full_name += GetTypeName(elem); } BISON_PRINT("Import Function not created yet: Internal name: %s Module: %s Function: %s -> Full %s\n", internal_name_.c_str(), module_name_.c_str(), function_name_.c_str(), full_name.c_str()); // Now get the result type. llvm::Type* result_type = ConvertType(result_); // Finally, create the function type. llvm::FunctionType* fct_type = llvm::FunctionType::get(result_type, params, false); // Now create the function. function_ = llvm::Function::Create(fct_type, llvm::Function::ExternalLinkage, full_name, module->GetModule()); } // Paranoid. assert(function_ != nullptr); // Finally we can return the function_. return function_; }
AGDOCTYPE CXMLDlg::GetCurrentDocType(HTREEITEM pItem) { HTREEITEM pChildItem = m_treeOutput.GetChildItem(pItem); if (!pChildItem) { ASSERT(false); return DOC_DEFAULT; } while (pChildItem) { CString szTitle; CString szValue; Separate(m_treeOutput.GetItemText(pChildItem), szTitle, szValue); if (!szTitle.CompareNoCase(_T("type"))) { return (ConvertType(szValue)); } pChildItem = m_treeOutput.GetNextItem(pChildItem, TVGN_NEXT); } ASSERT(false); return DOC_DEFAULT; }
void WasmImportFunction::Populate(std::vector<llvm::Type*>& params) { if (fields_ != nullptr) { for (std::list<FunctionField*>::const_iterator it = fields_->begin(); it != fields_->end(); it++) { const FunctionField* ff = *it; // Is it a result? const ResultField* rf = dynamic_cast<const ResultField*>(ff); if (rf != nullptr) { // We only support one return. assert(result_ == VOID); result_ = rf->GetType(); } else { // What about a parameter? const ParamField* pf = dynamic_cast<const ParamField*>(ff); // In the case of an import function, it has to either be a result or a parameter... assert (pf != nullptr); Local* local = pf->GetLocal(); const std::deque<LocalElem*>& list = local->GetList(); for (auto elem : list) { params.push_back(ConvertType(elem->GetType())); } } } } }
void CGUIDialogSmartPlaylistEditor::OnType() { CGUIMessage msg(GUI_MSG_ITEM_SELECTED, GetID(), CONTROL_TYPE); OnMessage(msg); m_playlist.SetType(ConvertType((PLAYLIST_TYPE)msg.GetParam1())); UpdateButtons(); }
/// HandleReturnType - This is invoked by the target-independent code for the /// return type. It potentially breaks down the argument and invokes methods /// on the client that indicate how its pieces should be handled. This /// handles things like returning structures via hidden parameters. void DefaultABI::HandleReturnType(tree type, tree fn, bool isBuiltin) { unsigned Offset = 0; const Type *Ty = ConvertType(type); if (Ty->isVectorTy()) { // Vector handling is weird on x86. In particular builtin and // non-builtin function of the same return types can use different // calling conventions. tree ScalarType = LLVM_SHOULD_RETURN_VECTOR_AS_SCALAR(type, isBuiltin); if (ScalarType) C.HandleAggregateResultAsScalar(ConvertType(ScalarType)); else if (LLVM_SHOULD_RETURN_VECTOR_AS_SHADOW(type, isBuiltin)) C.HandleScalarShadowResult(Ty->getPointerTo(), false); else C.HandleScalarResult(Ty); } else if (Ty->isSingleValueType() || Ty->isVoidTy()) { // Return scalar values normally. C.HandleScalarResult(Ty); } else if (doNotUseShadowReturn(type, fn, C.getCallingConv())) { tree SingleElt = LLVM_SHOULD_RETURN_SELT_STRUCT_AS_SCALAR(type); if (SingleElt && TYPE_SIZE(SingleElt) && TREE_CODE(TYPE_SIZE(SingleElt)) == INTEGER_CST && TREE_INT_CST_LOW(TYPE_SIZE_UNIT(type)) == TREE_INT_CST_LOW(TYPE_SIZE_UNIT(SingleElt))) { C.HandleAggregateResultAsScalar(ConvertType(SingleElt)); } else { // Otherwise return as an integer value large enough to hold the entire // aggregate. if (const Type *AggrTy = LLVM_AGGR_TYPE_FOR_STRUCT_RETURN(type, C.getCallingConv())) C.HandleAggregateResultAsAggregate(AggrTy); else if (const Type* ScalarTy = LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN(type, &Offset)) C.HandleAggregateResultAsScalar(ScalarTy, Offset); else { assert(0 && "Unable to determine how to return this aggregate!"); abort(); } } } else { // If the function is returning a struct or union, we pass the pointer to // the struct as the first argument to the function. // FIXME: should return the hidden first argument for some targets // (e.g. ELF i386). C.HandleAggregateShadowResult(Ty->getPointerTo(), false); } }
llvm::Value* MemoryExpression::GetPointer(WasmFunction*fct, llvm::IRBuilder<>& builder) const { llvm::Type* ptr_type= nullptr; if (type_ == INT_32 || type_ == INT_64) { switch (size_) { case 8: ptr_type= llvm::Type::getInt8PtrTy(llvm::getGlobalContext()); break; case 16: ptr_type= llvm::Type::getInt16PtrTy(llvm::getGlobalContext()); break; case 32: ptr_type= llvm::Type::getInt32PtrTy(llvm::getGlobalContext()); break; case 64: ptr_type= llvm::Type::getInt64PtrTy(llvm::getGlobalContext()); break; default: assert(0); break; } } else { switch (size_) { case 32: ptr_type= llvm::Type::getFloatPtrTy(llvm::getGlobalContext()); break; case 64: ptr_type= llvm::Type::getDoublePtrTy(llvm::getGlobalContext()); break; default: assert(0); break; } } assert(ptr_type != nullptr); // Create the base address in the same right type. llvm::Type* dest_type = ConvertType(type_); llvm::Value* address_i = address_->Codegen(fct, builder); llvm::Value* local_base = fct->GetLocalBase(); llvm::Type* type_64 = llvm::Type::getInt64Ty(llvm::getGlobalContext()); local_base = builder.CreatePtrToInt(local_base, type_64, "base"); llvm::Type* address_type = address_i->getType(); assert(address_type->isIntegerTy() == true); int bw = address_i->getType()->getIntegerBitWidth(); // If not 64, transform it into 64. if (bw != 64) { address_i = HandleIntegerTypeCast(address_i, type_64, bw, 64, false, builder); } address_i = builder.CreateAdd(address_i, local_base, "add_with_offset"); return builder.CreateIntToPtr(address_i, ptr_type, "ptr"); }
void PostgreSqlDbAdapter::ConvertTable(Table* pTab) { SerializableList::compatibility_iterator node = pTab->GetFirstChildNode(); while( node ) { if( node->GetData()->IsKindOf( CLASSINFO(Column)) ) { Column* col = (Column*) node->GetData(); col->SetType(ConvertType(col->GetType())); } node = node->GetNext(); } }
///------------------------------------------------------------------ /// Retrieves a double property from the specified Node ///------------------------------------------------------------------ float GetDoubleProperty( const XMLNode& node, const std::string& propertyName, float defaultValue ) { std::string propertyString = GetPropertyValueAsString( node, propertyName ); float propertyValue = defaultValue ; if ( propertyString.length() ) ConvertType( propertyString, propertyValue ); return propertyValue ; }
// Return LLVM Type if TYPE can be returned as an aggregate, // otherwise return NULL. Type *llvm_mips_aggr_type_for_struct_return(tree type) { Type *Ty = ConvertType(type); StructType *STy = cast<StructType>(Ty); std::vector<Type *> ElementTypes; // Special handling for _Complex. if (llvm_mips_should_not_return_complex_in_memory(type)) { ElementTypes.push_back(Type::getDoubleTy(Context)); ElementTypes.push_back(Type::getDoubleTy(Context)); return StructType::get(Context, ElementTypes, STy->isPacked()); } return NULL; }
llvm::Value* Load::ResizeIntegerIfNeed(llvm::Value* value, llvm::Type* value_type, ETYPE destination_type, bool sign, llvm::IRBuilder<>& builder) { // Get size differences. int value_type_bw = value_type->getIntegerBitWidth(); size_t type_size = GetTypeSize(type_); if (value_type_bw != type_size) { // Then it depends on sign. value = HandleIntegerTypeCast(value, ConvertType(type_), value_type_bw, type_size, sign, builder); } return value; }
/** * @brief Set option value. * * Set new value for option. If automatic conversion is not allowed, * type of value must match to type set when option was initialised. * @param [in] value New value to set. * @param [in] allowConversion Is automatic type conversion allowed? * @sa COption::Init() */ int COption::Set(varprop::VariantValue value, bool allowConversion) { int retVal = OPT_OK; // Check that type matches varprop::VT_TYPE inType = value.GetType(); if (value.GetType() != m_value.GetType()) { if (allowConversion) { if (ConvertType(value, m_value.GetType())) return Set(value); } _RPTF1(_CRT_ERROR, "Wrong type for option: %s", m_strName.c_str()); return OPT_WRONG_TYPE; } switch (inType) { case varprop::VT_NULL: retVal = OPT_UNKNOWN_TYPE; break; case varprop::VT_BOOL: m_value.SetBool(value.GetBool()); break; case varprop::VT_INT: m_value.SetInt(value.GetInt()); break; case varprop::VT_FLOAT: m_value.SetFloat(value.GetFloat()); break; case varprop::VT_STRING: m_value.SetString(value.GetString()); break; case varprop::VT_TIME: m_value.SetTime(value.GetTime()); break; default: retVal = OPT_UNKNOWN_TYPE; } return retVal; }
/** * @brief Set option value. * * Set new value for option. If automatic conversion is not allowed, * type of value must match to type set when option was initialised. * @param [in] value New value to set. * @param [in] allowConversion Is automatic type conversion allowed? * @sa COption::Init() */ int COption::Set(const varprop::VariantValue& value, bool allowConversion) { int retVal = COption::OPT_OK; // Check that type matches varprop::VT_TYPE inType = value.GetType(); if (value.GetType() != m_value.GetType()) { if (allowConversion) { varprop::VariantValue val(value); if (ConvertType(val, m_value.GetType())) return Set(val); } return COption::OPT_WRONG_TYPE; } switch (inType) { case varprop::VT_NULL: retVal = OPT_UNKNOWN_TYPE; break; case varprop::VT_BOOL: m_value.SetBool(value.GetBool()); break; case varprop::VT_INT: m_value.SetInt(value.GetInt()); break; case varprop::VT_FLOAT: m_value.SetFloat(value.GetFloat()); break; case varprop::VT_STRING: m_value.SetString(value.GetString()); break; case varprop::VT_TIME: m_value.SetTime(value.GetTime()); break; default: retVal = OPT_UNKNOWN_TYPE; } return retVal; }
void AddTypeInstanceTemplateVariableTypes(Context& context, const AST::Node<AST::TypeInstance>& astTypeInstanceNode) { const auto typeInstance = context.scopeStack().back().typeInstance(); // Add types of template variables. for (auto astTemplateVarNode: *(astTypeInstanceNode->templateVariables)) { const auto& templateVarName = astTemplateVarNode->name; const auto semTemplateVar = typeInstance->namedTemplateVariables().at(templateVarName); const auto& astVarType = astTemplateVarNode->varType; const auto semVarType = ConvertType(context, astVarType); if (!semVarType->isBuiltInBool() && !semVarType->isBuiltInTypename()) { throw ErrorException(makeString("Template variable '%s' in type '%s' has invalid type '%s', at position %s.", templateVarName.c_str(), typeInstance->name().toString().c_str(), semVarType->toString().c_str(), astTemplateVarNode.location().toString().c_str())); } semTemplateVar->setType(semVarType); } }
/// ValidateRegisterVariable - Check that a static "asm" variable is /// well-formed. If not, emit error messages and return true. If so, return /// false. bool ValidateRegisterVariable(tree decl) { const char *Name = IDENTIFIER_POINTER(DECL_ASSEMBLER_NAME(decl)); int RegNumber = decode_reg_name(Name); const Type *Ty = ConvertType(TREE_TYPE(decl)); // If this has already been processed, don't emit duplicate error messages. if (DECL_LLVM_SET_P(decl)) { // Error state encoded into DECL_LLVM. return cast<ConstantInt>(DECL_LLVM(decl))->getZExtValue(); } /* Detect errors in declaring global registers. */ if (RegNumber == -1) error("%Jregister name not specified for %qD", decl, decl); else if (RegNumber < 0) error("%Jinvalid register name for %qD", decl, decl); else if (TYPE_MODE(TREE_TYPE(decl)) == BLKmode) error("%Jdata type of %qD isn%'t suitable for a register", decl, decl); #if 0 // FIXME: enable this. else if (!HARD_REGNO_MODE_OK(RegNumber, TYPE_MODE(TREE_TYPE(decl)))) error("%Jregister specified for %qD isn%'t suitable for data type", decl, decl); #endif else if (DECL_INITIAL(decl) != 0 && TREE_STATIC(decl)) error("global register variable has initial value"); else if (!Ty->isFirstClassType()) sorry("%JLLVM cannot handle register variable %qD, report a bug", decl, decl); else { if (TREE_THIS_VOLATILE(decl)) warning("volatile register variables don%'t work as you might wish"); SET_DECL_LLVM(decl, ConstantInt::getFalse()); return false; // Everything ok. } SET_DECL_LLVM(decl, ConstantInt::getTrue()); return true; }
HRESULT ConvertDeclaration( const D3DVERTEXELEMENT9 original[ MAX_VERTEX_ELEMENTS ], std::vector<D3D11_INPUT_ELEMENT_DESC>& output) { app::console() << std::endl; for( UINT i = 0; i < MAX_VERTEX_ELEMENTS; ++i ) { if( original[i].Stream == 0xFF ) break; // Convert this element D3D11_INPUT_ELEMENT_DESC item; item.SemanticName = ConvertSemantic( static_cast< D3DDECLUSAGE >( original[i].Usage ) ); item.SemanticIndex = original[i].UsageIndex; item.AlignedByteOffset = original[i].Offset; item.InputSlot = original[i].Stream; item.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; item.InstanceDataStepRate = 0; item.Format = ConvertType( static_cast< D3DDECLTYPE >( original[i].Type ) ); app::console() << item.SemanticName << std::endl; output.push_back(item); } return S_OK; }
// make_decl_llvm - Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL // should have static storage duration. In other words, it should not be an // automatic variable, including PARM_DECLs. // // There is, however, one exception: this function handles variables explicitly // placed in a particular register by the user. // // This function corresponds to make_decl_rtl in varasm.c, and is implicitly // called by DECL_LLVM if a decl doesn't have an LLVM set. // void make_decl_llvm(tree decl) { #ifdef ENABLE_CHECKING // Check that we are not being given an automatic variable. // A weak alias has TREE_PUBLIC set but not the other bits. if (TREE_CODE(decl) == PARM_DECL || TREE_CODE(decl) == RESULT_DECL || (TREE_CODE(decl) == VAR_DECL && !TREE_STATIC(decl) && !TREE_PUBLIC(decl) && !DECL_EXTERNAL(decl) && !DECL_REGISTER(decl))) abort(); // And that we were not given a type or a label. */ else if (TREE_CODE(decl) == TYPE_DECL || TREE_CODE(decl) == LABEL_DECL) abort (); #endif // For a duplicate declaration, we can be called twice on the // same DECL node. Don't discard the LLVM already made. if (DECL_LLVM_SET_P(decl)) return; if (errorcount || sorrycount) return; // Do not process broken code. // Global register variable with asm name, e.g.: // register unsigned long esp __asm__("ebp"); if (TREE_CODE(decl) != FUNCTION_DECL && DECL_REGISTER(decl)) { // This just verifies that the variable is ok. The actual "load/store" // code paths handle accesses to the variable. ValidateRegisterVariable(decl); return; } timevar_push(TV_LLVM_GLOBALS); const char *Name = ""; if (DECL_NAME(decl)) if (tree AssemblerName = DECL_ASSEMBLER_NAME(decl)) Name = IDENTIFIER_POINTER(AssemblerName); // Now handle ordinary static variables and functions (in memory). // Also handle vars declared register invalidly. if (Name[0] == 1) { #ifdef REGISTER_PREFIX if (strlen (REGISTER_PREFIX) != 0) { int reg_number = decode_reg_name(Name); if (reg_number >= 0 || reg_number == -3) error("%Jregister name given for non-register variable %qD", decl, decl); } #endif } // Specifying a section attribute on a variable forces it into a // non-.bss section, and thus it cannot be common. if (TREE_CODE(decl) == VAR_DECL && DECL_SECTION_NAME(decl) != NULL_TREE && DECL_INITIAL(decl) == NULL_TREE && DECL_COMMON(decl)) DECL_COMMON(decl) = 0; // Variables can't be both common and weak. if (TREE_CODE(decl) == VAR_DECL && DECL_WEAK(decl)) DECL_COMMON(decl) = 0; // Okay, now we need to create an LLVM global variable or function for this // object. Note that this is quite possibly a forward reference to the // object, so its type may change later. if (TREE_CODE(decl) == FUNCTION_DECL) { assert(Name[0] && "Function with empty name!"); // If this function has already been created, reuse the decl. This happens // when we have something like __builtin_memset and memset in the same file. Function *FnEntry = TheModule->getFunction(Name); if (FnEntry == 0) { unsigned CC; const FunctionType *Ty = TheTypeConverter->ConvertFunctionType(TREE_TYPE(decl), decl, NULL, CC); FnEntry = new Function(Ty, Function::ExternalLinkage, Name, TheModule); FnEntry->setCallingConv(CC); // Check for external weak linkage if (DECL_EXTERNAL(decl) && DECL_WEAK(decl)) FnEntry->setLinkage(Function::ExternalWeakLinkage); #ifdef TARGET_ADJUST_LLVM_LINKAGE TARGET_ADJUST_LLVM_LINKAGE(FnEntry,decl); #endif /* TARGET_ADJUST_LLVM_LINKAGE */ // Handle visibility style if (TREE_PUBLIC(decl)) { if (DECL_VISIBILITY(decl) == VISIBILITY_HIDDEN) FnEntry->setVisibility(GlobalValue::HiddenVisibility); else if (DECL_VISIBILITY(decl) == VISIBILITY_PROTECTED) FnEntry->setVisibility(GlobalValue::ProtectedVisibility); } assert(FnEntry->getName() == Name &&"Preexisting fn with the same name!"); } SET_DECL_LLVM(decl, FnEntry); } else { assert((TREE_CODE(decl) == VAR_DECL || TREE_CODE(decl) == CONST_DECL) && "Not a function or var decl?"); const Type *Ty = ConvertType(TREE_TYPE(decl)); GlobalVariable *GV ; // If we have "extern void foo", make the global have type {} instead of // type void. if (Ty == Type::VoidTy) Ty = StructType::get(std::vector<const Type*>(), false); if (Name[0] == 0) { // Global has no name. GV = new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage, 0, "", TheModule); // Check for external weak linkage if (DECL_EXTERNAL(decl) && DECL_WEAK(decl)) GV->setLinkage(GlobalValue::ExternalWeakLinkage); #ifdef TARGET_ADJUST_LLVM_LINKAGE TARGET_ADJUST_LLVM_LINKAGE(GV,decl); #endif /* TARGET_ADJUST_LLVM_LINKAGE */ // Handle visibility style if (TREE_PUBLIC(decl)) { if (DECL_VISIBILITY(decl) == VISIBILITY_HIDDEN) GV->setVisibility(GlobalValue::HiddenVisibility); else if (DECL_VISIBILITY(decl) == VISIBILITY_PROTECTED) GV->setVisibility(GlobalValue::ProtectedVisibility); } } else { // If the global has a name, prevent multiple vars with the same name from // being created. GlobalVariable *GVE = TheModule->getGlobalVariable(Name); if (GVE == 0) { GV = new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage,0, Name, TheModule); // Check for external weak linkage if (DECL_EXTERNAL(decl) && DECL_WEAK(decl)) GV->setLinkage(GlobalValue::ExternalWeakLinkage); #ifdef TARGET_ADJUST_LLVM_LINKAGE TARGET_ADJUST_LLVM_LINKAGE(GV,decl); #endif /* TARGET_ADJUST_LLVM_LINKAGE */ // Handle visibility style if (TREE_PUBLIC(decl)) { if (DECL_VISIBILITY(decl) == VISIBILITY_HIDDEN) GV->setVisibility(GlobalValue::HiddenVisibility); else if (DECL_VISIBILITY(decl) == VISIBILITY_PROTECTED) GV->setVisibility(GlobalValue::ProtectedVisibility); } // If GV got renamed, then there is already an object with this name in // the symbol table. If this happens, the old one must be a forward // decl, just replace it with a cast of the new one. if (GV->getName() != Name) { Function *F = TheModule->getFunction(Name); assert(F && F->isDeclaration() && "A function turned into a global?"); // Replace any uses of "F" with uses of GV. Value *FInNewType = ConstantExpr::getBitCast(GV, F->getType()); F->replaceAllUsesWith(FInNewType); // Update the decl that points to F. changeLLVMValue(F, FInNewType); // Now we can give GV the proper name. GV->takeName(F); // F is now dead, nuke it. F->eraseFromParent(); } } else { GV = GVE; // Global already created, reuse it. } } if ((TREE_READONLY(decl) && !TREE_SIDE_EFFECTS(decl)) || TREE_CODE(decl) == CONST_DECL) { if (DECL_EXTERNAL(decl)) { // Mark external globals constant even though they could be marked // non-constant in the defining translation unit. The definition of the // global determines whether the global is ultimately constant or not, // marking this constant will allow us to do some extra (legal) // optimizations that we would otherwise not be able to do. (In C++, // any global that is 'C++ const' may not be readonly: it could have a // dynamic initializer. // GV->setConstant(true); } else { // Mark readonly globals with constant initializers constant. if (DECL_INITIAL(decl) != error_mark_node && // uninitialized? DECL_INITIAL(decl) && (TREE_CONSTANT(DECL_INITIAL(decl)) || TREE_CODE(DECL_INITIAL(decl)) == STRING_CST)) GV->setConstant(true); } } // Set thread local (TLS) if (TREE_CODE(decl) == VAR_DECL && DECL_THREAD_LOCAL(decl)) GV->setThreadLocal(true); SET_DECL_LLVM(decl, GV); } timevar_pop(TV_LLVM_GLOBALS); }
/// HandleArgument - This is invoked by the target-independent code for each /// argument type passed into the function. It potentially breaks down the /// argument and invokes methods on the client that indicate how its pieces /// should be handled. This handles things like decimating structures into /// their fields. void DefaultABI::HandleArgument(tree type, std::vector<const Type*> &ScalarElts, Attributes *Attributes) { unsigned Size = 0; bool DontCheckAlignment = false; const Type *Ty = ConvertType(type); // Figure out if this field is zero bits wide, e.g. {} or [0 x int]. Do // not include variable sized fields here. std::vector<const Type*> Elts; if (Ty->isVoidTy()) { // Handle void explicitly as an opaque type. const Type *OpTy = OpaqueType::get(getGlobalContext()); C.HandleScalarArgument(OpTy, type); ScalarElts.push_back(OpTy); } else if (isPassedByInvisibleReference(type)) { // variable size -> by-ref. const Type *PtrTy = Ty->getPointerTo(); C.HandleByInvisibleReferenceArgument(PtrTy, type); ScalarElts.push_back(PtrTy); } else if (Ty->isVectorTy()) { if (LLVM_SHOULD_PASS_VECTOR_IN_INTEGER_REGS(type)) { PassInIntegerRegisters(type, ScalarElts, 0, false); } else if (LLVM_SHOULD_PASS_VECTOR_USING_BYVAL_ATTR(type)) { C.HandleByValArgument(Ty, type); if (Attributes) { *Attributes |= Attribute::ByVal; *Attributes |= Attribute::constructAlignmentFromInt(LLVM_BYVAL_ALIGNMENT(type)); } } else { C.HandleScalarArgument(Ty, type); ScalarElts.push_back(Ty); } } else if (LLVM_TRY_PASS_AGGREGATE_CUSTOM(type, ScalarElts, C.getCallingConv(), &C)) { // Nothing to do. } else if (Ty->isSingleValueType()) { C.HandleScalarArgument(Ty, type); ScalarElts.push_back(Ty); } else if (LLVM_SHOULD_PASS_AGGREGATE_AS_FCA(type, Ty)) { C.HandleFCAArgument(Ty, type); } else if (LLVM_SHOULD_PASS_AGGREGATE_IN_MIXED_REGS(type, Ty, C.getCallingConv(), Elts)) { if (!LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS(Elts, ScalarElts, C.isShadowReturn(), C.getCallingConv())) PassInMixedRegisters(Ty, Elts, ScalarElts); else { C.HandleByValArgument(Ty, type); if (Attributes) { *Attributes |= Attribute::ByVal; *Attributes |= Attribute::constructAlignmentFromInt(LLVM_BYVAL_ALIGNMENT(type)); } } } else if (LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR(type, Ty)) { C.HandleByValArgument(Ty, type); if (Attributes) { *Attributes |= Attribute::ByVal; *Attributes |= Attribute::constructAlignmentFromInt(LLVM_BYVAL_ALIGNMENT(type)); } } else if (LLVM_SHOULD_PASS_AGGREGATE_IN_INTEGER_REGS(type, &Size, &DontCheckAlignment)) { PassInIntegerRegisters(type, ScalarElts, Size, DontCheckAlignment); } else if (isZeroSizedStructOrUnion(type)) { // Zero sized struct or union, just drop it! ; } else if (TREE_CODE(type) == RECORD_TYPE) { for (tree Field = TYPE_FIELDS(type); Field; Field = TREE_CHAIN(Field)) if (TREE_CODE(Field) == FIELD_DECL) { const tree Ftype = getDeclaredType(Field); const Type *FTy = ConvertType(Ftype); unsigned FNo = GET_LLVM_FIELD_INDEX(Field); assert(FNo != ~0U && "Case not handled yet!"); // Currently, a bvyal type inside a non-byval struct is a zero-length // object inside a bigger object on x86-64. This type should be // skipped (but only when it is inside a bigger object). // (We know there currently are no other such cases active because // they would hit the assert in FunctionPrologArgumentConversion:: // HandleByValArgument.) if (!LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR(Ftype, FTy)) { C.EnterField(FNo, Ty); HandleArgument(getDeclaredType(Field), ScalarElts); C.ExitField(); } } } else if (TREE_CODE(type) == COMPLEX_TYPE) { C.EnterField(0, Ty); HandleArgument(TREE_TYPE(type), ScalarElts); C.ExitField(); C.EnterField(1, Ty); HandleArgument(TREE_TYPE(type), ScalarElts); C.ExitField(); } else if ((TREE_CODE(type) == UNION_TYPE) || (TREE_CODE(type) == QUAL_UNION_TYPE)) { HandleUnion(type, ScalarElts); } else if (TREE_CODE(type) == ARRAY_TYPE) { const ArrayType *ATy = cast<ArrayType>(Ty); for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i) { C.EnterField(i, Ty); HandleArgument(TREE_TYPE(type), ScalarElts); C.ExitField(); } } else { assert(0 && "unknown aggregate type!"); abort(); } }
ConditionalReader::ConditionalReader(PClip _child, const char* filename, const char _varname[], bool _show, IScriptEnvironment* env) : GenericVideoFilter(_child), show(_show), variableName(_varname) { FILE * f; char *line; int lines; if ((f = fopen(filename, "rb")) == NULL) env->ThrowError("ConditionalReader: Could not open file '%s'.", filename); lines = 0; mode = MODE_UNKNOWN; while ((line = readline(f)) != NULL) { char *ptr; int fields; lines++; /* We skip spaces */ ptr = skipspaces(line); /* Skip coment lines or empty lines */ if(iscomment(ptr) || *ptr == '\0') { free(line); continue; } if (mode == MODE_UNKNOWN) { // We have not recieved a mode - We expect type. char keyword [1024]; char type [1024]; fields = sscanf(ptr,"%1023s %1023s", keyword, type); if (fields) { if (!strcasecmp((const char*)keyword, "type")) { if (!strcasecmp((const char*)type, "int")) { mode = MODE_INT; intVal = new int[vi.num_frames]; } else if (!strcasecmp((const char*)type, "float")) { mode = MODE_FLOAT; floatVal = new float[vi.num_frames]; } else if (!strcasecmp((const char*)type, "bool")) { mode = MODE_BOOL; boolVal = new bool[vi.num_frames]; } else { ThrowLine("ConditionalReader: Unknown 'type' specified in line %d", lines, env); }// end if compare type }// end if compare keyword }// end if fields } else { // We have a defined mode and allocated the values. char keyword [1024]; char type [1024]; fields = sscanf(ptr,"%1023s %1023s", keyword, type); if (!strcasecmp((const char*)keyword, "default")) { AVSValue def = ConvertType((const char*)type, lines, env); SetRange(0, vi.num_frames-1, def); free(line); continue; } // end if "default" if (ptr[0] == 'R' || ptr[0] == 'r') { // Range ptr++; ptr = skipspaces(ptr); int start; int stop; char value [64]; fields = sscanf(ptr, "%d %d %63s", &start, &stop, value); if (fields != 3) ThrowLine("ConditionalReader: Could not read range in line %d", lines, env); if (start > stop) ThrowLine("ConditionalReader: The start frame is after the end frame in line %d", lines, env); AVSValue set = ConvertType((const char*)value, lines, env); SetRange(start, stop, set); } else if (ptr[0] == 'I' || ptr[0] == 'i') { // Interpolate if (mode == MODE_BOOL) ThrowLine("ConditionalReader: Cannot interpolate booleans in line %d", lines, env); ptr++; ptr = skipspaces(ptr); int start; int stop; char start_value [64]; char stop_value [64]; fields = sscanf(ptr, "%d %d %63s %63s", &start, &stop, start_value, stop_value); if (fields != 4) ThrowLine("ConditionalReader: Could not read interpolation range in line %d", lines, env); if (start > stop) ThrowLine("ConditionalReader: The start frame is after the end frame in line %d", lines, env); AVSValue set_start = ConvertType((const char*)start_value, lines, env); AVSValue set_stop = ConvertType((const char*)stop_value, lines, env); int range = stop-start; double diff = set_stop.AsFloat() - set_start.AsFloat(); for (int i = 0; i<=range; i++) { double where = (double)(i)/(double)range; double n = where * diff + set_start.AsFloat(); SetFrame(i+start, (mode == MODE_FLOAT) ? AVSValue(n) : AVSValue((int) n)); } } else { char value [64]; int cframe; fields = sscanf(ptr, "%d %63s", &cframe, value); if (fields == 2) { AVSValue set = ConvertType((const char*)value, lines, env); SetFrame(cframe, set); } else { AVXLOG_INFO("ConditionalReader: Ignored line %d.\n", lines); } } } // End we have defined type free(line); }// end while still some file left to read. /* We are done with the file */ fclose(f); if (mode == MODE_UNKNOWN) env->ThrowError("ConditionalReader: Mode was not defined!"); }
entity_member_t* FindEntityMembers(object_t* object, char* str) { int i, j, k, x, count, hit, hit_count, array_count; char *temp_str, *value_string, **current_array; void *variable_arrays[] = { FileVariableNames, PhysicsVariableNames, DirectVariableNames, 0}; void *temp_test, **temp_array; entity_member_t *members; if(!object || !str) { return NULL; } if(!object->keys) { return NULL; } //Count KV Pairs and Prepare to Collect Hits count = CountMem(object->keys, sizeof(jsmntok_t)); members = (entity_member_t*) malloc(sizeof(entity_member_t)*(count+1)); if(!members) { return NULL; } memset(members, 0, sizeof(entity_member_t)*(count+1)); hit = 0; hit_count = 0; value_string = NULL; //Iterate through single value keys for(i = 0; i < count; i++) { temp_str = JsmnToString(&object->keys[i], str); if(!temp_str) { continue; } //Iterate through variable names for(j = 0; variable_arrays[j]; j++) { current_array = (char**) variable_arrays[j]; for(k = 0; current_array[k]; k++) { if(!strcmp(temp_str, current_array[k])) { hit = 1; value_string = JsmnToString(&object->values[i], str); members[hit_count].data = ConvertType( j, k, value_string ); members[hit_count].member_type = j; EntityMemberSetType(&members[hit_count], k); break; } } if(hit) { hit = 0; hit_count++; if(value_string) free(value_string); if(temp_str) free(temp_str); break; } } } count = CountMem(object->children, sizeof(object_t)); //Check if no valueable targets if( (hit_count + count) == 0) { if(members) free(members); return NULL; } members = (entity_member_t*) realloc(members, sizeof(entity_member_t)*(hit_count+count+1)); if(!members) { return NULL; } for(i = 0; i < count; i++) { temp_str = object->children[i].name; if(!temp_str) { continue; } for(j = 0; variable_arrays[j]; j++) { current_array = (char**) variable_arrays[j]; for(k = 0; current_array[k]; k++) { if(!strcmp(temp_str, current_array[k])) { hit = 1; array_count = CountMem(object->children[i].values, sizeof(jsmntok_t)); //Test for variable size to adjust our array value_string = JsmnToString(&object->children[i].values[0], str); temp_test = ConvertType(j, k, value_string ); if(value_string) free(value_string); #ifdef _WIN32 x = _msize(temp_test); #elif _LINUX x = malloc_size(temp_test); #endif //Assign Values Accordingly if(x == sizeof(char*)) { temp_array = (void**) malloc(sizeof(char*)*(array_count+1)); if(!temp_array) { hit = 0; break; } ((char**)temp_array)[0] = (char*) temp_test; for(x = 1; x < array_count; x++) { value_string = JsmnToString(&object->children[i].values[x], str); temp_test = ConvertType(j, k, value_string ); ((char**)temp_array)[x] = (char*) temp_test; if(value_string) free(value_string); } ((char**)temp_array)[array_count] = NULL; } else if( x == sizeof(cpFloat) ) { temp_array = (void**) malloc(sizeof(cpFloat)*(array_count+1)); if(!temp_array) { hit = 0; break; } ((cpFloat*)temp_array)[0] = *(cpFloat*) temp_test; if(temp_test) free(temp_test); for(x = 1; x < array_count; x++) { value_string = JsmnToString(&object->children[i].values[x], str); temp_test = ConvertType(j, k, value_string ); if(temp_test) { ((cpFloat*)temp_array)[x] = *(cpFloat*) temp_test; free(temp_test); } if(value_string) free(value_string); } ((cpFloat*)temp_array)[array_count] = (cpFloat) 0; } else { if(temp_test) free(temp_test); break; } members[hit_count].data = temp_array; members[hit_count].member_type = j; EntityMemberSetType(&members[hit_count], k); break; } } if(hit) { hit = 0; hit_count++; break; } } } //Check if we never hit a value if(hit_count == 0) { if(members) free(members); return NULL; } memset(&members[hit_count], 0, sizeof(entity_member_t)); return members; }
SEM::Var* ConvertVar(Context& context, const Debug::VarInfo::Kind varKind, const AST::Node<AST::TypeVar>& astTypeVarNode) { const auto& location = astTypeVarNode.location(); switch (astTypeVarNode->kind()) { case AST::TypeVar::ANYVAR: { throw ErrorException("'Any' vars not yet implemented for uninitialised variables."); } case AST::TypeVar::NAMEDVAR: { const auto& varName = astTypeVarNode->name(); // Search all scopes outside of the current scope. const auto searchStartPosition = 1; if (varKind != Debug::VarInfo::VAR_MEMBER && !performSearch(context, Name::Relative() + varName, searchStartPosition).isNone()) { throw ErrorException(makeString("Variable '%s' shadows existing object at position %s.", varName.c_str(), location.toString().c_str())); } const auto varType = ConvertType(context, astTypeVarNode->namedType()); // 'final' keyword uses a different lval type (which doesn't support // moving or re-assignment). const bool isFinalLval = astTypeVarNode->isFinal(); const auto lvalType = makeLvalType(context, isFinalLval, varType); const auto var = SEM::Var::Basic(varType, lvalType); var->setMarkedUnused(astTypeVarNode->isUnused()); var->setOverrideConst(astTypeVarNode->isOverrideConst()); attachVar(context, varName, astTypeVarNode, var, varKind); return var; } case AST::TypeVar::PATTERNVAR: { const auto varType = ConvertType(context, astTypeVarNode->patternType())->resolveAliases(); if (!varType->isDatatype()) { throw ErrorException(makeString("Can't pattern match for non-datatype '%s' at position %s.", varType->toString().c_str(), location.toString().c_str())); } const auto& astChildTypeVars = astTypeVarNode->typeVarList(); const auto& typeChildVars = varType->getObjectType()->variables(); if (astChildTypeVars->size() != typeChildVars.size()) { throw ErrorException(makeString("%llu pattern match children specified; %llu expected (for type '%s') at position %s.", (unsigned long long) astChildTypeVars->size(), (unsigned long long) typeChildVars.size(), varType->toString().c_str(), location.toString().c_str())); } const auto templateVarMap = varType->generateTemplateVarMap(); std::vector<SEM::Var*> children; for (size_t i = 0; i < typeChildVars.size(); i++) { const auto& astVar = astChildTypeVars->at(i); children.push_back(ConvertVar(context, varKind, astVar)); } return SEM::Var::Composite(varType, children); } } std::terminate(); }
void MaterialDatabaseReader::ProcessElementBeginContent() { if( MATCH_ELEMENT_NAME( L"Material" ) ) { m_pCurrentMaterial = nullptr; const WCHAR* strName = FindAttribute( L"Name" ); if( !strName ) return; m_pCurrentMaterial = new ExportMaterialDefinition(); m_pCurrentMaterial->strName = ConvertString( strName ); const WCHAR* strDesc = FindAttribute( L"Description" ); if( strDesc ) m_pCurrentMaterial->strDescription = ConvertString( strDesc ); g_Materials.push_back( m_pCurrentMaterial ); return; } else if( MATCH_ELEMENT_NAME( L"Parameter" ) ) { if( !m_pCurrentMaterial ) return; if( m_pCurrentParam ) return; const WCHAR* strName = FindAttribute( L"Name" ); if( !strName ) return; m_pCurrentParam = new ExportMaterialParameterDefinition(); m_pCurrentParam->strName = ConvertString( strName ); m_pCurrentMaterial->Parameters.push_back( m_pCurrentParam ); const WCHAR* strDisplayName = FindAttribute( L"DisplayName" ); if( strDisplayName ) m_pCurrentParam->strDisplayName = ConvertString( strDisplayName ); else m_pCurrentParam->strDisplayName = m_pCurrentParam->strName; const WCHAR* strDesc = FindAttribute( L"Description" ); m_pCurrentParam->strDescription = ConvertString( strDesc ); const WCHAR* strDisplayHint = FindAttribute( L"DisplayHint" ); if( !strDisplayHint || wcslen( strDisplayHint ) < 1 ) m_pCurrentParam->strDisplayHint = " "; else m_pCurrentParam->strDisplayHint = ConvertString( strDisplayHint ); const WCHAR* strLoaderHint = FindAttribute( L"LoadHint" ); m_pCurrentParam->strLoaderHint = ConvertString( strLoaderHint ); const WCHAR* strType = FindAttribute( L"Type" ); m_pCurrentParam->ParamType = ConvertType( strType ); const WCHAR* strVisible = FindAttribute( L"ToolVisible" ); m_pCurrentParam->bVisibleInTool = ConvertBool( strVisible, false ); const WCHAR* strExport = FindAttribute( L"Export" ); m_pCurrentParam->bExportToContentFile = ConvertBool( strExport, true ); const WCHAR* strDetectAlpha = FindAttribute( L"DetectAlpha" ); m_pCurrentParam->bDetectAlpha = ConvertBool( strDetectAlpha, false ); const WCHAR* strDefaultValue = FindAttribute( L"DefaultValue" ); m_pCurrentParam->strDefaultValue = ConvertString( strDefaultValue ); return; } }
/// emit_global_to_llvm - Emit the specified VAR_DECL or aggregate CONST_DECL to /// LLVM as a global variable. This function implements the end of /// assemble_variable. void emit_global_to_llvm(tree decl) { if (errorcount || sorrycount) return; // FIXME: Support alignment on globals: DECL_ALIGN. // FIXME: DECL_PRESERVE_P indicates the var is marked with attribute 'used'. // Global register variables don't turn into LLVM GlobalVariables. if (TREE_CODE(decl) == VAR_DECL && DECL_REGISTER(decl)) return; timevar_push(TV_LLVM_GLOBALS); // Get or create the global variable now. GlobalVariable *GV = cast<GlobalVariable>(DECL_LLVM(decl)); // Convert the initializer over. Constant *Init; if (DECL_INITIAL(decl) == 0 || DECL_INITIAL(decl) == error_mark_node) { // This global should be zero initialized. Reconvert the type in case the // forward def of the global and the real def differ in type (e.g. declared // as 'int A[]', and defined as 'int A[100]'). Init = Constant::getNullValue(ConvertType(TREE_TYPE(decl))); } else { assert((TREE_CONSTANT(DECL_INITIAL(decl)) || TREE_CODE(DECL_INITIAL(decl)) == STRING_CST) && "Global initializer should be constant!"); // Temporarily set an initializer for the global, so we don't infinitely // recurse. If we don't do this, we can hit cases where we see "oh a global // with an initializer hasn't been initialized yet, call emit_global_to_llvm // on it". When constructing the initializer it might refer to itself. // this can happen for things like void *G = &G; // GV->setInitializer(UndefValue::get(GV->getType()->getElementType())); Init = TreeConstantToLLVM::Convert(DECL_INITIAL(decl)); } // If we had a forward definition that has a type that disagrees with our // initializer, insert a cast now. This sort of thing occurs when we have a // global union, and the LLVM type followed a union initializer that is // different from the union element used for the type. if (GV->getType()->getElementType() != Init->getType()) { GV->removeFromParent(); GlobalVariable *NGV = new GlobalVariable(Init->getType(), GV->isConstant(), GlobalValue::ExternalLinkage, 0, GV->getName(), TheModule); GV->replaceAllUsesWith(ConstantExpr::getBitCast(NGV, GV->getType())); delete GV; SET_DECL_LLVM(decl, NGV); GV = NGV; } // Set the initializer. GV->setInitializer(Init); // Set thread local (TLS) if (TREE_CODE(decl) == VAR_DECL && DECL_THREAD_LOCAL(decl)) GV->setThreadLocal(true); // Set the linkage. if (!TREE_PUBLIC(decl)) { GV->setLinkage(GlobalValue::InternalLinkage); } else if (DECL_WEAK(decl) || DECL_ONE_ONLY(decl) || (DECL_COMMON(decl) && // DECL_COMMON is only meaningful if no init (!DECL_INITIAL(decl) || DECL_INITIAL(decl) == error_mark_node))) { // llvm-gcc also includes DECL_VIRTUAL_P here. GV->setLinkage(GlobalValue::WeakLinkage); } else if (DECL_COMDAT(decl)) { GV->setLinkage(GlobalValue::LinkOnceLinkage); } #ifdef TARGET_ADJUST_LLVM_LINKAGE TARGET_ADJUST_LLVM_LINKAGE(GV,decl); #endif /* TARGET_ADJUST_LLVM_LINKAGE */ // Handle visibility style if (TREE_PUBLIC(decl)) { if (DECL_VISIBILITY(decl) == VISIBILITY_HIDDEN) GV->setVisibility(GlobalValue::HiddenVisibility); else if (DECL_VISIBILITY(decl) == VISIBILITY_PROTECTED) GV->setVisibility(GlobalValue::ProtectedVisibility); } // Set the section for the global. if (TREE_CODE(decl) == VAR_DECL || TREE_CODE(decl) == CONST_DECL) { if (DECL_SECTION_NAME(decl)) { GV->setSection(TREE_STRING_POINTER(DECL_SECTION_NAME(decl))); #ifdef LLVM_IMPLICIT_TARGET_GLOBAL_VAR_SECTION } else if (const char *Section = LLVM_IMPLICIT_TARGET_GLOBAL_VAR_SECTION(decl)) { GV->setSection(Section); #endif } // Set the alignment for the global if one of the following condition is met // 1) DECL_ALIGN_UNIT does not match alignment as per ABI specification // 2) DECL_ALIGN is set by user. if (DECL_ALIGN_UNIT(decl)) { unsigned TargetAlign = getTargetData().getABITypeAlignment(GV->getType()->getElementType()); if (DECL_USER_ALIGN(decl) || TargetAlign != DECL_ALIGN_UNIT(decl)) GV->setAlignment(DECL_ALIGN_UNIT(decl)); } // Handle used decls if (DECL_PRESERVE_P (decl)) { const Type *SBP= PointerType::get(Type::Int8Ty); AttributeUsedGlobals.push_back(ConstantExpr::getBitCast(GV, SBP)); } // Add annotate attributes for globals if (DECL_ATTRIBUTES(decl)) AddAnnotateAttrsToGlobal(GV, decl); } if (TheDebugInfo) TheDebugInfo->EmitGlobalVariable(GV, decl); timevar_pop(TV_LLVM_GLOBALS); }
bool CGUIDialogSmartPlaylistEditor::OnMessage(CGUIMessage& message) { switch ( message.GetMessage() ) { case GUI_MSG_CLICKED: { int iControl = message.GetSenderId(); int iAction = message.GetParam1(); if (iControl == CONTROL_RULE_LIST && (iAction == ACTION_SELECT_ITEM || iAction == ACTION_MOUSE_LEFT_CLICK)) OnRuleList(GetSelectedItem()); else if (iControl == CONTROL_RULE_ADD) OnRuleAdd(); else if (iControl == CONTROL_RULE_EDIT) OnRuleList(GetSelectedItem()); else if (iControl == CONTROL_RULE_REMOVE) OnRuleRemove(GetSelectedItem()); else if (iControl == CONTROL_NAME) OnEditChanged(iControl, m_playlist.m_playlistName); else if (iControl == CONTROL_OK) OnOK(); else if (iControl == CONTROL_CANCEL) OnCancel(); else if (iControl == CONTROL_MATCH) OnMatch(); else if (iControl == CONTROL_LIMIT) OnLimit(); else if (iControl == CONTROL_ORDER_FIELD) OnOrder(); else if (iControl == CONTROL_ORDER_DIRECTION) OnOrderDirection(); else if (iControl == CONTROL_TYPE) OnType(); else if (iControl == CONTROL_GROUP_BY) OnGroupBy(); else if (iControl == CONTROL_GROUP_MIXED) OnGroupMixed(); else return CGUIDialog::OnMessage(message); return true; } break; case GUI_MSG_FOCUSED: if (message.GetControlId() == CONTROL_RULE_REMOVE || message.GetControlId() == CONTROL_RULE_EDIT) HighlightItem(GetSelectedItem()); else { if (message.GetControlId() == CONTROL_RULE_LIST) UpdateRuleControlButtons(); HighlightItem(-1); } break; case GUI_MSG_WINDOW_INIT: { const std::string& startupList = message.GetStringParam(0); if (!startupList.empty()) { int party = 0; if (URIUtils::PathEquals(startupList, CProfilesManager::GetInstance().GetUserDataItem("PartyMode.xsp"))) party = 1; else if (URIUtils::PathEquals(startupList, CProfilesManager::GetInstance().GetUserDataItem("PartyMode-Video.xsp"))) party = 2; if ((party && !XFILE::CFile::Exists(startupList)) || m_playlist.Load(startupList)) { m_path = startupList; if (party == 1) m_mode = "partymusic"; else if (party == 2) m_mode = "partyvideo"; else { PLAYLIST_TYPE type = ConvertType(m_playlist.GetType()); if (type == TYPE_SONGS || type == TYPE_ALBUMS || type == TYPE_ARTISTS) m_mode = "music"; else m_mode = "video"; } } else return false; } } break; } return CGUIDialog::OnMessage(message); }
ConditionalReader::ConditionalReader(PClip _child, const char* filename, const char _varname[], bool _show, IScriptEnvironment* env) : GenericVideoFilter(_child), show(_show), variableName(_varname), mode(MODE_UNKNOWN), offset(0), stringcache(0) { FILE * f; char *line = 0; int lines; if ((f = fopen(filename, "rb")) == NULL) env->ThrowError("ConditionalReader: Could not open file '%s'.", filename); lines = 0; try { while ((line = readline(f)) != NULL) { char *ptr; int fields; lines++; /* We skip spaces */ ptr = skipspaces(line); /* Skip coment lines or empty lines */ if(iscomment(ptr) || *ptr == '\0') { free(line); line = 0; continue; } if (mode == MODE_UNKNOWN) { // We have not recieved a mode - We expect type. char* keyword = ptr; ptr = findspace(ptr); if (*ptr) { *ptr++ = '\0'; if (!lstrcmpi(keyword, "type")) { /* We skip spaces */ char* type = skipspaces(ptr); ptr = findspace(type); *ptr = '\0'; if (!lstrcmpi(type, "int")) { mode = MODE_INT; intVal = new int[vi.num_frames]; } else if (!lstrcmpi(type, "float")) { mode = MODE_FLOAT; floatVal = new float[vi.num_frames]; } else if (!lstrcmpi(type, "bool")) { mode = MODE_BOOL; boolVal = new bool[vi.num_frames]; } else if (!lstrcmpi(type, "string")) { mode = MODE_STRING; stringVal = new const char*[vi.num_frames]; } else { ThrowLine("ConditionalReader: Unknown 'Type' specified in line %d", lines, env); }// end if compare type SetRange(0, vi.num_frames-1, AVSValue()); }// end if compare keyword }// end if fields } else { // We have a defined mode and allocated the values. char* keyword = ptr; char* type = findspace(keyword); if (*type) *type++ = '\0'; if (!lstrcmpi(keyword, "default")) { AVSValue def = ConvertType(type, lines, env); SetRange(0, vi.num_frames-1, def); } else if (!lstrcmpi(keyword, "offset")) { fields = sscanf(type, "%d", &offset); if (fields != 1) ThrowLine("ConditionalReader: Could not read Offset in line %d", lines, env); } else if (keyword[0] == 'R' || keyword[0] == 'r') { // Range int start; int stop; type = skipspaces(type); fields = sscanf(type, "%d", &start); type = findspace(type); type = skipspaces(type); fields += sscanf(type, "%d", &stop); type = findspace(type); if (!*type || fields != 2) ThrowLine("ConditionalReader: Could not read Range in line %d", lines, env); if (start > stop) ThrowLine("ConditionalReader: The Range start frame is after the end frame in line %d", lines, env); AVSValue set = ConvertType(type+1, lines, env); SetRange(start, stop, set); } else if (keyword[0] == 'I' || keyword[0] == 'i') { // Interpolate if (mode == MODE_BOOL) ThrowLine("ConditionalReader: Cannot Interpolate booleans in line %d", lines, env); if (mode == MODE_STRING) ThrowLine("ConditionalReader: Cannot Interpolate strings in line %d", lines, env); type = skipspaces(type); int start; int stop; char start_value[64]; char stop_value[64]; fields = sscanf(type, "%d %d %63s %63s", &start, &stop, start_value, stop_value); if (fields != 4) ThrowLine("ConditionalReader: Could not read Interpolation range in line %d", lines, env); if (start > stop) ThrowLine("ConditionalReader: The Interpolation start frame is after the end frame in line %d", lines, env); start_value[63] = '\0'; AVSValue set_start = ConvertType(start_value, lines, env); stop_value[63] = '\0'; AVSValue set_stop = ConvertType(stop_value, lines, env); const int range = stop-start; const double diff = (set_stop.AsFloat() - set_start.AsFloat()) / range; for (int i = 0; i<=range; i++) { const double n = i * diff + set_start.AsFloat(); SetFrame(i+start, (mode == MODE_FLOAT) ? AVSValue(n) : AVSValue((int)(n+0.5))); } } else { int cframe; fields = sscanf(keyword, "%d", &cframe); if (*type && fields == 1) { AVSValue set = ConvertType(type, lines, env); SetFrame(cframe, set); } else { ThrowLine("ConditionalReader: Do not understand line %d", lines, env); } } } // End we have defined type free(line); line = 0; }// end while still some file left to read. } catch (...) { if (line) free(line); fclose(f); CleanUp(); throw; } /* We are done with the file */ fclose(f); if (mode == MODE_UNKNOWN) env->ThrowError("ConditionalReader: Type was not defined!"); }
llvm::Value* Unop::Codegen(WasmFunction* fct, llvm::IRBuilder<>& builder) { bool is_intrinsic = false; OPERATION op = operation_->GetOperation(); switch (op) { case CLZ_OPER: case CTZ_OPER: case POPCNT_OPER: case SQRT_OPER: case ABS_OPER: case CEIL_OPER: case FLOOR_OPER: case NEAREST_OPER: is_intrinsic = true; break; case TRUNC_OPER: { // Use the intrinsic value if we have the same type. // Basically this is used for f32.trunc or f64.trunc... ConversionOperation* conversion = dynamic_cast<ConversionOperation*>(operation_); assert(conversion != nullptr); is_intrinsic = (conversion->GetSrc() == conversion->GetDest()); break; } default: break; } if (is_intrinsic == true) { WasmModule* wasm_module = fct->GetModule(); ETYPE type = operation_->GetType(); llvm::Intrinsic::ID intrinsic; bool extra_true_arg = false; switch (op) { case CLZ_OPER: intrinsic = llvm::Intrinsic::ctlz; // We need to pass true as second argument to produce defined result for zero. extra_true_arg = true; break; case CTZ_OPER: intrinsic = llvm::Intrinsic::cttz; // We need to pass true as second argument to produce defined result for zero. extra_true_arg = true; break; case POPCNT_OPER: intrinsic = llvm::Intrinsic::ctpop; break; case SQRT_OPER: intrinsic = llvm::Intrinsic::sqrt; break; case ABS_OPER: intrinsic = llvm::Intrinsic::fabs; break; case CEIL_OPER: intrinsic = llvm::Intrinsic::ceil; break; case FLOOR_OPER: intrinsic = llvm::Intrinsic::floor; break; case TRUNC_OPER: intrinsic = llvm::Intrinsic::trunc; break; case NEAREST_OPER: intrinsic = llvm::Intrinsic::nearbyint; break; default: assert(0); return nullptr; } llvm::Function* intrinsic_fct = wasm_module->GetOrCreateIntrinsic(intrinsic, type); assert(intrinsic_fct != nullptr); std::vector<Value*> arg; arg.push_back(only_->Codegen(fct, builder)); if (extra_true_arg) { llvm::Value* val_true = llvm::ConstantInt::get(llvm::getGlobalContext(), APInt(1, 0, false)); arg.push_back(val_true); } return builder.CreateCall(intrinsic_fct, arg, "calltmp"); } else { llvm::Value* rv = only_->Codegen(fct, builder); ETYPE type = operation_->GetType(); switch (op) { case NEG_OPER: { llvm::Value* lv; if (type == FLOAT_32) { lv = llvm::ConstantFP::get(llvm::getGlobalContext(), APFloat(0.0f)); } else { lv = llvm::ConstantFP::get(llvm::getGlobalContext(), APFloat(0.0)); } return builder.CreateFSub(lv, rv, "subtmp"); } case REINTERPRET_OPER: return builder.CreateBitCast(rv, ConvertType(type), DumpOperation(op)); case EXTEND_OPER: case TRUNC_OPER: case PROMOTE_OPER: case DEMOTE_OPER: case CONVERT_OPER: case WRAP_OPER: { ConversionOperation* conversion = dynamic_cast<ConversionOperation*>(operation_); assert(conversion != nullptr); return HandleTypeCasts(rv, ConvertType(conversion->GetSrc()), ConvertType(type), operation_->GetSignedOrOrdered(), builder); } } assert(0); return nullptr; } }