| /src/external/apache2/llvm/dist/clang/lib/CodeGen/ |
| CGCUDARuntime.h | 46 // Global variable properties that must be passed to CUDA runtime.
50 Variable, // Variable
58 unsigned Constant : 1; // Constant variable.
59 unsigned Managed : 1; // Managed variable.
86 /// Check whether a variable is a device variable and register it if true.
94 /// Returns function or variable name on device side even if the current
|
| CGObjCRuntime.cpp | 120 const VarDecl *Variable;
172 Handler.Variable = CatchDecl;
249 bool EndCatchMightThrow = (Handler.Variable == nullptr);
257 if (const VarDecl *CatchParam = Handler.Variable) {
|
| CGStmt.cpp | 66 // local variable map) which could be used by subsequent statements.
807 // scope of the variable that is declared extends from its point
978 // Create a cleanup scope for the condition variable cleanups.
982 // the continue block. Otherwise, if there is no condition variable, we can
983 // form the continue block now. If there is a condition variable, we can't
986 // ensure that there are no continues from the condition variable that jump
996 // If the for statement has a condition scope, emit the local variable
1001 // We have entered the condition variable's scope, so we're now able to
1098 // The loop body, consisting of the specified body and the loop variable.
1126 // Create a separate cleanup scope for the loop variable and body
[all...] |
| CGBlocks.cpp | 201 // If an equivalent block descriptor global variable exists, return it.
210 // If there isn't an equivalent block descriptor global variable, create a new
422 // We can only do this if the variable is const.
433 // If the variable doesn't have any initializer (shouldn't this be
507 // If the variable is captured by an enclosing block or lambda expression,
513 // If the captured variable is a non-escaping __block variable, the field
514 // type is the reference type. If the variable is a __block variable that
515 // already has a reference type, the field type is the variable's type
570 const VarDecl *variable = CI.getVariable(); local
911 const VarDecl *variable = CI.getVariable(); local
1545 const VarDecl *variable = CI.getVariable(); local
1582 const VarDecl *variable = CI.getVariable(); local
[all...] |
| CodeGenFunction.h | 409 /// Lookup the captured field decl for a variable.
578 /// when the NRVO has been applied to this variable.
705 /// An i1 variable indicating whether or not the @finally is
709 /// An i8* variable into which the exception pointer to rethrow
961 /// Sets the address of the variable \p LocalVD to be \p TempAddr in
963 /// \return true if at least one variable was set already, false otherwise.
990 /// \return true if at least one variable is using new address, false
1037 /// Registers \p LocalVD variable as a private and apply \p PrivateGen
1038 /// function for it to generate corresponding private variable. \p
1039 /// PrivateGen returns an address of the generated private variable
[all...] |
| /src/external/apache2/llvm/dist/llvm/tools/llvm-exegesis/lib/ |
| MCInstrDescView.h | 12 /// Arguments that are explicit and independant (non tied) also have a Variable
35 // A variable represents the value associated to an Operand or a set of Operands
37 struct Variable {
38 // Returns the index of this Variable inside Instruction's Variable.
41 // Returns the index of the Operand linked to this Variable.
44 // Returns whether this Variable has more than one Operand linked to it.
47 // The indices of the operands tied to this Variable.
50 // The index of this Variable in Instruction.Variables and its associated
64 // - VariableIndex: the index of the Variable holding the value for this Operan
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Analysis/ |
| CloneDetection.h | 353 /// Describes an occurrence of a variable reference in a statement.
357 /// The statement in the code where the variable was referenced.
370 /// Adds a new variable referenced to this pattern.
371 /// \param VarDecl The declaration of the variable that is referenced.
372 /// \param Mention The SourceRange where this variable is referenced.
375 /// Adds each referenced variable from the given statement.
392 /// The variable which referencing in this clone was against the pattern.
393 const VarDecl *Variable;
394 /// Where the variable was referenced.
396 /// The variable that should have been referenced to follow the pattern
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/Sema/ |
| SemaStmtAsm.cpp | 196 // Handle cases where the expression is a variable
197 const VarDecl *Variable = dyn_cast<VarDecl>(AsmDeclRef->getDecl());
198 if (Variable && Variable->getStorageClass() == SC_Register) {
199 if (AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>())
|
| AnalysisBasedWarnings.cpp | 811 /// uninitialized use of a variable.
988 /// uninitialized variable. This manages the different forms of diagnostic
996 // Inspect the initializer of the variable declaration which is
1032 // Report where the variable was declared when the use wasn't within
1386 // loop if the base object is a local variable -- local variables are often
1469 Variable,
1477 ObjectKind = Variable;
1575 // variable, but the root cause is an idiomatic self-init. We want
1599 // Skip further diagnostics for this variable. We try to warn only
1600 // on the first point at which a variable is used uninitialized
[all...] |
| SemaChecking.cpp | 823 // else we just point to the variable reference.
992 // called in: no events and no variable arguments.
10620 // detect if a value in a variable has not changed. This clearly can
13170 // ArraySubscriptExpr is on the RHS of a variable initialization.
13173 // This is not the right CC for (e.g.) a variable initialization.
14151 // variable length array types.
14298 // FIXME: If VD is captured by copy or is an escaping __block variable,
14718 VarDecl *Variable = nullptr;
14733 /// Consider whether capturing the given variable can possibly lead to
14736 // In ARC, it's captured strongly iff the variable has __stron
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Index/ |
| IndexSymbol.h | 40 Variable,
|
| /src/external/apache2/llvm/dist/llvm/lib/FileCheck/ |
| FileCheckImpl.h | 213 /// Class to represent an undefined variable error, which quotes that
214 /// variable's name when printed.
230 /// Print name of variable associated with this error.
232 OS << "undefined variable: " << VarName;
258 /// Class representing a numeric variable and its associated current value.
261 /// Name of the numeric variable.
264 /// Format to use for expressions using this variable without an explicit
268 /// Value of numeric variable, if defined, or None otherwise.
275 /// Line number where this variable is defined, or None if defined before
276 /// input is parsed. Used to determine whether a variable is defined on th
[all...] |
| /src/external/apache2/llvm/dist/clang/utils/TableGen/ |
| NeonEmitter.cpp | 286 // Variable
289 /// A variable is a simple class that just has a type and a name.
290 class Variable {
295 Variable() : T(Type::getVoid()), N("") {}
296 Variable(Type T, std::string N) : T(std::move(T)), N(std::move(N)) {}
338 std::map<std::string, Variable> Variables;
349 /// The return variable.
350 Variable RetVar;
351 /// A postfix to apply to every variable. Defaults to "".
507 void emitReverseVariable(Variable &Dest, Variable &Src)
[all...] |
| /src/external/apache2/llvm/dist/llvm/examples/Kaleidoscope/Chapter5/ |
| toy.cpp | 147 /// VariableExprAST - Expression class for referencing a variable, like "a".
307 if (CurTok != '(') // Simple variable ref.
573 // Look this variable up in the function.
576 return LogErrorV("Unknown variable name");
679 // variable = phi [start, loopheader], [nextvariable, loopend]
685 // nextvariable = variable + step
690 // Emit the start code first, without 'variable' in scope.
708 PHINode *Variable =
710 Variable->addIncoming(StartVal, PreheaderBB);
712 // Within the loop, the variable is defined equal to the PHI node. If i
[all...] |
| /src/external/apache2/llvm/dist/llvm/examples/Kaleidoscope/Chapter6/ |
| toy.cpp | 155 /// VariableExprAST - Expression class for referencing a variable, like "a".
341 if (CurTok != '(') // Simple variable ref.
665 // Look this variable up in the function.
668 return LogErrorV("Unknown variable name");
791 // variable = phi [start, loopheader], [nextvariable, loopend]
797 // nextvariable = variable + step
802 // Emit the start code first, without 'variable' in scope.
820 PHINode *Variable =
822 Variable->addIncoming(StartVal, PreheaderBB);
824 // Within the loop, the variable is defined equal to the PHI node. If i
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Analysis/Analyses/ |
| ThreadSafetyTIL.h | 343 /// A named variable, e.g. "x".
345 /// There are two distinct places in which a Variable can appear in the AST.
346 /// A variable declaration introduces a new variable, and can occur in 3 places:
351 /// If a variable occurs in any other location, it is a reference to an existing
352 /// variable declaration -- e.g. 'x' in (x * y + z). To save space, we don't
353 /// allocate a separate AST node for variable references; a reference is just a
355 class Variable : public SExpr {
358 /// Let-variable
368 Variable(StringRef s, SExpr *D = nullptr
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Sema/ |
| Initialization.h | 52 /// The entity being initialized is a variable.
108 /// variable in a lambda.
173 /// The name of the variable being captured by an EK_LambdaCapture.
182 /// EK_TemplateParameter, the variable, binding, or template parameter.
183 VD Variable;
214 /// Create the initialization entity for a variable.
216 : Kind(EK), Type(Var->getType()), Variable{Var, false, false} {}
233 Variable{Member, Implicit, DefaultMemberInit} {}
248 /// Create the initialization entity for a variable.
295 Entity.Variable = {Param, false, false}
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Demangle/ |
| MicrosoftDemangleNodes.h | 378 VariableSymbolNode *Variable = nullptr;
|
| /src/external/apache2/llvm/dist/llvm/lib/CodeGen/ |
| LiveDebugVariables.cpp | 79 "Debug Variable Analysis", false, false)
83 "Debug Variable Analysis", false, false)
99 /// Describes a debug variable value by location number and expression along
279 /// A user value is a part of a debug info user variable.
282 /// holds part of a user variable. The part is identified by a byte offset.
288 const DILocalVariable *Variable; ///< The debug info variable we are part of.
289 /// The part of the variable we describe.
291 DebugLoc dl; ///< The debug location for the variable. This is
325 : Variable(var), Fragment(Fragment), dl(std::move(L)), leader(this)
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/CodeGen/SelectionDAG/ |
| SelectionDAGISel.cpp | 605 const MDNode *Variable = MI->getDebugVariable();
612 assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
618 IsIndirect, LDI->second, Variable, Expr);
638 // Use MI's debug location, which describes where Variable was
642 CopyUseMI->getOperand(0).getReg(), Variable, Expr);
1324 assert(DI->getVariable() && "Missing variable");
1338 // Check if the variable is a static alloca or a byval or inalloca
|
| SelectionDAGBuilder.cpp | 1167 void SelectionDAGBuilder::dropDanglingDebugInfo(const DILocalVariable *Variable,
1173 if (DanglingVariable == Variable && Expr->fragmentsOverlap(DanglingExpr)) {
1209 DILocalVariable *Variable = DI->getVariable();
1211 assert(Variable->isValidLocationForIntrinsic(dl) &&
1221 if (!EmitFuncArgumentDbgValue(V, Variable, Expr, dl, false, Val)) {
1232 SDV = getDbgValue(Val, Variable, Expr, dl,
1242 DAG.getConstantDbgValue(Variable, Expr, Undef, dl, DbgSDNodeOrder);
1273 // variable. FIXME: Further work could recover those too.
1305 // any earlier variable location.
2598 /// variable if there exists one
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/IR/ |
| LLVMContextImpl.h | 1013 // in most cases this param for local variable is zero (for function param
1054 // in most cases this param for local variable is zero (for function param
1103 Metadata *Variable;
1106 MDNodeKeyImpl(Metadata *Variable, Metadata *Expression)
1107 : Variable(Variable), Expression(Expression) {}
1109 : Variable(N->getRawVariable()), Expression(N->getRawExpression()) {}
1112 return Variable == RHS->getRawVariable() &&
1116 unsigned getHashValue() const { return hash_combine(Variable, Expression); }
|
| /src/sys/arch/hppa/hppa/ |
| db_disasm.c | 85 enum datasize { Byte, Halfword, Word, Doubleword, Quadword, Variable };
258 * The argument "i" must be an addressable variable (i.e., not a register
259 * variable or an expression... but see BitfX below), "n" must be an
564 #define BVB 0x30, 0x00, 0, 0 /* BRANCH on VARIABLE BIT */
604 #define VSHD 0x34, 0x00, 19, 3 /* VARIABLE SHIFT DOUBLE */
606 #define VEXTRU 0x34, 0x04, 19, 3 /* VARIABLE EXTRACT RIGHT UNSIGNED */
607 #define VEXTRS 0x34, 0x05, 19, 3 /* VARIABLE EXTRACT RIGHT SIGNED */
610 #define VDEP 0x35, 0x01, 19, 3 /* VARIABLE DEPOSIT */
612 #define VDEPI 0x35, 0x05, 19, 3 /* VARIABLE DEPOSIT IMMED */
614 #define ZVDEP 0x35, 0x00, 19, 3 /* ZERO and VARIABLE DEPOSIT *
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/MC/MCParser/ |
| MasmParser.cpp | 384 /// maps assembly-time variable names to variables.
385 struct Variable {
392 StringMap<Variable> Variables;
1297 // Variable symbols may not be marked as defined, so check those
1298 // explicitly. If we know it's a variable, we have a definition for
1551 // Variables use case-insensitive symbol names; if this is a variable, we
1559 // If this is an absolute variable reference, substitute it now to preserve
1568 return Error(EndLoc, "unexpected modifier on variable reference");
2143 // Diagnose attempt to use a variable as a label.
2533 // Finally, we check if this is allocating a variable with user-defined type
[all...] |
