Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "MOS" ]

[]

[ "<s>", "void", "msp430_register_pragmas", "(", "void", ")", "{", "c_register_addr_space", "(", "\"__near\"", ",", "ADDR_SPACE_NEAR", ")", ";", "if", "(", "msp430x", ")", "c_register_addr_space", "(", "\"__far\"", ",", "ADDR_SPACE_FAR", ")", ";", "}", "</s>" ]

[ "Implements", "REGISTER_TARGET_PRAGMAS", "." ]

[ "msp430", "\"__near\"", "\"__far\"" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", ")", "return", "false", ";", "assert", "(", "!", "MO", ".", "getSubReg", "(", ")", "&&", "\"Subregs should be eliminated!\"", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetARMGVSymbol", "(", "MO", ".", "getGlobal", "(", ")", ",", "MO", ".", "getTargetFlags", "(", ")", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "if", "(", "Subtarget", "->", "genExecuteOnly", "(", ")", ")", "llvm_unreachable", "(", "\"execute-only should not generate constant pools\"", ")", ";", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "APFloat", "Val", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "bool", "ignored", ";", "Val", ".", "convert", "(", "APFloat", "::", "IEEEdouble", "(", ")", ",", "APFloat", "::", "rmTowardZero", ",", "&", "ignored", ")", ";", "MCOp", "=", "MCOperand", "::", "createFPImm", "(", "Val", ".", "convertToDouble", "(", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "ARM", "ARM", "\"unknown operand type\"", "ARM::CPSR", "\"Subregs should be eliminated!\"", "ARM", "\"execute-only should not generate constant pools\"" ]

[]

[ "<s>", "bool", "HexagonRemoveExtendArgs", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "unsigned", "Idx", "=", "1", ";", "for", "(", "Function", "::", "arg_iterator", "AI", "=", "F", ".", "arg_begin", "(", ")", ",", "AE", "=", "F", ".", "arg_end", "(", ")", ";", "AI", "!=", "AE", ";", "++", "AI", ",", "++", "Idx", ")", "{", "if", "(", "F", ".", "paramHasAttr", "(", "Idx", ",", "Attribute", "::", "SExt", ")", ")", "{", "Argument", "*", "Arg", "=", "AI", ";", "if", "(", "!", "isa", "<", "PointerType", ">", "(", "Arg", "->", "getType", "(", ")", ")", ")", "{", "for", "(", "Instruction", "::", "use_iterator", "UI", "=", "Arg", "->", "use_begin", "(", ")", ";", "UI", "!=", "Arg", "->", "use_end", "(", ")", ";", ")", "{", "if", "(", "isa", "<", "SExtInst", ">", "(", "*", "UI", ")", ")", "{", "Instruction", "*", "Use", "=", "cast", "<", "Instruction", ">", "(", "*", "UI", ")", ";", "SExtInst", "*", "SI", "=", "new", "SExtInst", "(", "Arg", ",", "Use", "->", "getType", "(", ")", ")", ";", "assert", "(", "EVT", "::", "getEVT", "(", "SI", "->", "getType", "(", ")", ")", "==", "(", "EVT", "::", "getEVT", "(", "Use", "->", "getType", "(", ")", ")", ")", ")", ";", "++", "UI", ";", "Use", "->", "replaceAllUsesWith", "(", "SI", ")", ";", "Instruction", "*", "First", "=", "F", ".", "getEntryBlock", "(", ")", ".", "begin", "(", ")", ";", "SI", "->", "insertBefore", "(", "First", ")", ";", "Use", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "++", "UI", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "Hexagon", "Hexagon", "1" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "SrcVTy", ",", "const", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "Align", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", "=", "nullptr", ")", "{", "if", "(", "CostKind", "!=", "TTI", "::", "TCK_RecipThroughput", ")", "return", "1", ";", "assert", "(", "SrcVTy", "->", "isVectorTy", "(", ")", "&&", "\"Unexpected data type for Gather/Scatter\"", ")", ";", "unsigned", "VF", "=", "cast", "<", "FixedVectorType", ">", "(", "SrcVTy", ")", "->", "getNumElements", "(", ")", ";", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "PtrTy", "&&", "Ptr", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "cast", "<", "VectorType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "assert", "(", "PtrTy", "&&", "\"Unexpected type for Ptr argument\"", ")", ";", "unsigned", "AddressSpace", "=", "PtrTy", "->", "getAddressSpace", "(", ")", ";", "bool", "Scalarize", "=", "false", ";", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "!", "isLegalMaskedGather", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "!", "isLegalMaskedScatter", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "ST", "->", "hasAVX512", "(", ")", "&&", "(", "VF", "==", "2", "||", "(", "VF", "==", "4", "&&", "!", "ST", "->", "hasVLX", "(", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "Scalarize", ")", "return", "getGSScalarCost", "(", "Opcode", ",", "SrcVTy", ",", "VariableMask", ",", "Alignment", ",", "AddressSpace", ")", ";", "return", "getGSVectorCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "Alignment", ",", "AddressSpace", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "X86", "X86", "1", "\"Unexpected data type for Gather/Scatter\"", "\"Unexpected type for Ptr argument\"", "2", "4" ]

[]

[ "<s>", "virtual", "StringRef", "getPassName", "(", ")", "const", "{", "return", "\"TGSI DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "TGSI", "\"TGSI DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "bool", "WebAssemblyInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", ")", "const", "{", "const", "auto", "&", "MFI", "=", "*", "MBB", ".", "getParent", "(", ")", "->", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", ".", "isCFGStackified", "(", ")", ")", "return", "true", ";", "bool", "HaveCond", "=", "false", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ".", "terminators", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "true", ";", "case", "WebAssembly", "::", "BR_IF", ":", "if", "(", "HaveCond", ")", "return", "true", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "true", ")", ")", ";", "Cond", ".", "push_back", "(", "MI", ".", "getOperand", "(", "1", ")", ")", ";", "TBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "HaveCond", "=", "true", ";", "break", ";", "case", "WebAssembly", "::", "BR_UNLESS", ":", "if", "(", "HaveCond", ")", "return", "true", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "false", ")", ")", ";", "Cond", ".", "push_back", "(", "MI", ".", "getOperand", "(", "1", ")", ")", ";", "TBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "HaveCond", "=", "true", ";", "break", ";", "case", "WebAssembly", "::", "BR", ":", "if", "(", "!", "HaveCond", ")", "TBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "else", "FBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "break", ";", "case", "WebAssembly", "::", "BR_ON_EXN", ":", "if", "(", "HaveCond", ")", "return", "true", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "true", ")", ")", ";", "Cond", ".", "push_back", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ";", "TBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "HaveCond", "=", "true", ";", "break", ";", "}", "if", "(", "MI", ".", "isBarrier", "(", ")", ")", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly::BR_IF", "1", "0", "WebAssembly::BR_UNLESS", "1", "0", "WebAssembly::BR", "0", "0", "WebAssembly::BR_ON_EXN", "2", "0" ]

[]

[ "<s>", "static", "void", "aarch64_record_vector_load_arg", "(", "tree", "addr", ")", "{", "tree", "decl", "=", "aarch64_vector_load_decl", "(", "addr", ")", ";", "if", "(", "!", "decl", ")", "return", ";", "if", "(", "!", "cfun", "->", "machine", "->", "vector_load_decls", ")", "cfun", "->", "machine", "->", "vector_load_decls", "=", "hash_set", "<", "tree", ">", "::", "create_ggc", "(", "31", ")", ";", "cfun", "->", "machine", "->", "vector_load_decls", "->", "add", "(", "decl", ")", ";", "}", "</s>" ]

[ "We", "'ve", "seen", "a", "vector", "load", "from", "address", "ADDR", ".", "Record", "it", "in", "vector_load_decls", ",", "if", "appropriate", "." ]

[ "aarch64", "31" ]

[]

[ "<s>", "bool", "SILowerControlFlowPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "HaveCf", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "Next", "=", "llvm", "::", "next", "(", "I", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "llvm", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AMDGPU", "::", "SI_IF", ":", "If", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "Else", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_BREAK", ":", "Break", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "IfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE_BREAK", ":", "ElseBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "Loop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "HaveCf", "=", "true", ";", "EndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "Branch", "(", "MI", ")", ";", "break", ";", "}", "}", "}", "unsigned", "ShaderType", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "ShaderType", ";", "if", "(", "HaveCf", "&&", "ShaderType", "==", "ShaderType", "::", "PIXEL", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "if", "(", "MBB", ".", "succ_empty", "(", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBB", ".", "getFirstNonPHI", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_CBRANCH_EXECNZ", ")", ")", ".", "addImm", "(", "3", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "EXP", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0x09", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "1", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "AMDGPU", "::", "SREG_LIT_0", ")", ".", "addReg", "(", "AMDGPU", "::", "SREG_LIT_0", ")", ".", "addReg", "(", "AMDGPU", "::", "SREG_LIT_0", ")", ".", "addReg", "(", "AMDGPU", "::", "SREG_LIT_0", ")", ";", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_ENDPGM", ")", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "R600", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "3", "0", "0x09", "0", "1", "1" ]

[]

[ "<s>", "void", "LC3MCInstLower", "::", "Initialize", "(", "Mangler", "*", "M", ",", "MCContext", "*", "C", ")", "{", "Mang", "=", "M", ";", "Ctx", "=", "C", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "LC3", "LC3" ]

[]

[ "<s>", "static", "reg_class_t", "sparc_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "sri", "->", "icode", "=", "CODE_FOR_nothing", ";", "sri", "->", "extra_cost", "=", "0", ";", "if", "(", "FP_REG_CLASS_P", "(", "rclass", ")", "&&", "(", "mode", "==", "HImode", "||", "mode", "==", "QImode", ")", "&&", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "||", "(", "(", "GET_CODE", "(", "x", ")", "==", "REG", "||", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "&&", "true_regnum", "(", "x", ")", "==", "-", "1", ")", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "TARGET_ARCH32", "&&", "rclass", "==", "EXTRA_FP_REGS", "&&", "mode", "==", "DFmode", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "!", "mem_min_alignment", "(", "x", ",", "8", ")", ")", "return", "FP_REGS", ";", "if", "(", "(", "(", "TARGET_CM_MEDANY", "&&", "symbolic_operand", "(", "x", ",", "mode", ")", ")", "||", "(", "TARGET_CM_EMBMEDANY", "&&", "text_segment_operand", "(", "x", ",", "mode", ")", ")", ")", "&&", "!", "flag_pic", ")", "{", "if", "(", "in_p", ")", "sri", "->", "icode", "=", "direct_optab_handler", "(", "reload_in_optab", ",", "mode", ")", ";", "else", "sri", "->", "icode", "=", "direct_optab_handler", "(", "reload_out_optab", ",", "mode", ")", ";", "return", "NO_REGS", ";", "}", "if", "(", "TARGET_VIS3", "&&", "TARGET_ARCH32", ")", "{", "int", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "(", "rclass", "==", "EXTRA_FP_REGS", "&&", "SPARC_INT_REG_P", "(", "regno", ")", ")", "||", "(", "(", "general_or_i64_p", "(", "rclass", ")", "||", "rclass", "==", "GENERAL_OR_FP_REGS", ")", "&&", "SPARC_FP_REG_P", "(", "regno", ")", ")", ")", "{", "sri", "->", "extra_cost", "=", "2", ";", "return", "FP_REGS", ";", "}", "}", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "TARGET_SECONDARY_RELOAD", "." ]

[ "sparc", "0", "1", "8", "2" ]

[]

[ "<s>", "void", "print", "(", "DiagnosticPrinter", "&", "DP", ")", "const", "override", "{", "DP", "<<", "Msg", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "mayBeEmittedAsTailCall", "(", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", ")", "return", "false", ";", "CallSite", "CS", "(", "CI", ")", ";", "CallingConv", "::", "ID", "CalleeCC", "=", "CS", ".", "getCallingConv", "(", ")", ";", "if", "(", "!", "IsTailCallConvention", "(", "CalleeCC", ")", "&&", "CalleeCC", "!=", "CallingConv", "::", "C", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "WebAssemblyDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "case", "InlineAsm", "::", "Constraint_m", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "ARMInputExMap", ">", "ARMInputExMap", "::", "create", "(", "Input", "&", "pInput", ")", "{", "std", "::", "unique_ptr", "<", "ARMInputExMap", ">", "exMap", "(", "new", "ARMInputExMap", "(", ")", ")", ";", "LDContext", "*", "ctx", "=", "pInput", ".", "context", "(", ")", ";", "for", "(", "LDContext", "::", "sect_iterator", "it", "=", "ctx", "->", "sectBegin", "(", ")", ",", "end", "=", "ctx", "->", "sectEnd", "(", ")", ";", "it", "!=", "end", ";", "++", "it", ")", "{", "LDSection", "*", "sect", "=", "*", "it", ";", "if", "(", "sect", "->", "type", "(", ")", "==", "llvm", "::", "ELF", "::", "SHT_ARM_EXIDX", ")", "{", "ARMExSectionTuple", "*", "exTuple", "=", "exMap", "->", "getOrCreateByExSection", "(", "*", "sect", ")", ";", "exTuple", "->", "setExIdxSection", "(", "sect", ")", ";", "exTuple", "->", "setTextSection", "(", "sect", "->", "getLink", "(", ")", ")", ";", "if", "(", "sect", "->", "getLink", "(", ")", "==", "NULL", ")", "{", "fatal", "(", "diag", "::", "eh_missing_text_section", ")", "<<", "sect", "->", "name", "(", ")", "<<", "pInput", ".", "name", "(", ")", ";", "}", "}", "}", "ARMInputExMap", "::", "iterator", "it", "=", "exMap", "->", "begin", "(", ")", ";", "ARMInputExMap", "::", "iterator", "end", "=", "exMap", "->", "end", "(", ")", ";", "while", "(", "it", "!=", "end", ")", "{", "ARMExSectionTuple", "*", "exTuple", "=", "it", "->", "second", ".", "get", "(", ")", ";", "LDSection", "*", "const", "text", "=", "exTuple", "->", "getTextSection", "(", ")", ";", "LDSection", "*", "const", "exIdx", "=", "exTuple", "->", "getExIdxSection", "(", ")", ";", "if", "(", "(", "text", "->", "kind", "(", ")", "==", "LDFileFormat", "::", "Ignore", ")", "||", "(", "text", "->", "kind", "(", ")", "==", "LDFileFormat", "::", "Folded", ")", ")", "{", "exIdx", "->", "setKind", "(", "LDFileFormat", "::", "Ignore", ")", ";", "ARMInputExMap", "::", "iterator", "deadIt", "=", "it", "++", ";", "exMap", "->", "erase", "(", "deadIt", ")", ";", "continue", ";", "}", "RegionFragment", "*", "textFrag", "=", "findRegionFragment", "(", "*", "text", ")", ";", "RegionFragment", "*", "exIdxFrag", "=", "findRegionFragment", "(", "*", "exIdx", ")", ";", "exTuple", "->", "setTextFragment", "(", "textFrag", ")", ";", "exTuple", "->", "setExIdxFragment", "(", "exIdxFrag", ")", ";", "if", "(", "exIdxFrag", "==", "NULL", ")", "{", "ARMInputExMap", "::", "iterator", "deadIt", "=", "it", "++", ";", "exMap", "->", "erase", "(", "deadIt", ")", ";", "continue", ";", "}", "++", "it", ";", "}", "return", "exMap", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "ARM", "ARM", "ARMInputExMap::create", "ARM", "ARM", "ARM", "ARM", "ARMInputExMap::iterator", "ARMInputExMap::iterator", "ARM", "ARMInputExMap::iterator", "ARMInputExMap::iterator" ]

[]

[ "<s>", "unsigned", "PPCVSXSwapRemoval", "::", "lookThruCopyLike", "(", "unsigned", "SrcReg", ",", "unsigned", "VecIdx", ")", "{", "MachineInstr", "*", "MI", "=", "MRI", "->", "getVRegDef", "(", "SrcReg", ")", ";", "if", "(", "!", "MI", "->", "isCopyLike", "(", ")", ")", "return", "SrcReg", ";", "unsigned", "CopySrcReg", ",", "CopySrcSubreg", ";", "if", "(", "MI", "->", "isCopy", "(", ")", ")", "{", "CopySrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CopySrcSubreg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getSubReg", "(", ")", ";", "}", "else", "{", "assert", "(", "MI", "->", "isSubregToReg", "(", ")", "&&", "\"bad opcode for lookThruCopyLike\"", ")", ";", "CopySrcReg", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CopySrcSubreg", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getSubReg", "(", ")", ";", "}", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "CopySrcReg", ")", ")", "{", "SwapVector", "[", "VecIdx", "]", ".", "MentionsPhysVR", "=", "1", ";", "return", "CopySrcReg", ";", "}", "if", "(", "CopySrcSubreg", "!=", "0", ")", "{", "SwapVector", "[", "VecIdx", "]", ".", "HasImplicitSubreg", "=", "1", ";", "return", "CopySrcReg", ";", "}", "return", "lookThruCopyLike", "(", "CopySrcReg", ",", "VecIdx", ")", ";", "}", "</s>" ]

[ "Returns", "the", "original", "SrcReg", "unless", "it", "is", "the", "target", "of", "a", "copy-like", "operation", ",", "in", "which", "case", "we", "chain", "backwards", "through", "all", "such", "operations", "to", "the", "ultimate", "source", "register", "." ]

[ "PowerPC", "PPC", "1", "1", "\"bad opcode for lookThruCopyLike\"", "2", "2", "1", "0", "1" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "MSP430Operand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "return", "make_unique", "<", "MSP430Operand", ">", "(", "k_Reg", ",", "RegNum", ",", "S", ",", "E", ")", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "int", "next_insn_test_reg", "(", "rtx", "insn", ",", "rtx", "reg", ")", "{", "rtx", "body", ";", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "insn", ")", "!=", "INSN", ")", "return", "0", ";", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "sets_cc0_p", "(", "body", ")", "!=", "1", ")", "return", "0", ";", "if", "(", "rtx_equal_p", "(", "XEXP", "(", "body", ",", "1", ")", ",", "reg", ")", "==", "0", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Returns", "1", "if", "the", "next", "insn", "after", "'insn", "'", "is", "a", "test", "of", "the", "register", "'reg", "'", ".", "This", "is", "used", "to", "decide", "whether", "a", "move", "that", "set", "flags", "should", "be", "used", "instead", "." ]

[ "m68hc11", "0", "1", "0", "1", "0", "0", "1" ]

[]

[ "<s>", "static", "void", "frv_register_nop", "(", "rtx", "nop", ")", "{", "nop", "=", "make_insn_raw", "(", "nop", ")", ";", "NEXT_INSN", "(", "nop", ")", "=", "0", ";", "PREV_INSN", "(", "nop", ")", "=", "0", ";", "frv_nops", "[", "frv_num_nops", "++", "]", "=", "nop", ";", "}", "</s>" ]

[ "Add", "an", "instruction", "with", "pattern", "NOP", "to", "frv_nops", "[", "]", "." ]

[ "frv", "0", "0" ]

[]

[ "<s>", "void", "M68kOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "KindTy", "::", "Invalid", ":", "OS", "<<", "\"invalid\"", ";", "break", ";", "case", "KindTy", "::", "Token", ":", "OS", "<<", "\"token '\"", "<<", "Token", "<<", "\"'\"", ";", "break", ";", "case", "KindTy", "::", "Imm", ":", "OS", "<<", "\"immediate \"", "<<", "Imm", ";", "break", ";", "case", "KindTy", "::", "MemOp", ":", "MemOp", ".", "print", "(", "OS", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "M68k", "M68k", "\"invalid\"", "\"token '\"", "\"'\"", "\"immediate \"" ]

[]

[ "<s>", "static", "void", "mmix_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "static_chain", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "mem", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "2", "*", "UNITS_PER_WORD", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "2", "*", "UNITS_PER_WORD", ")", ";", "emit_move_insn", "(", "mem", ",", "static_chain", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "3", "*", "UNITS_PER_WORD", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "0", ")", ";", "emit_insn", "(", "gen_sync_icache", "(", "mem", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", "-", "1", ")", ")", ")", ";", "}", "</s>" ]

[ "Set", "the", "static", "chain", "and", "function", "pointer", "field", "in", "the", "trampoline", ".", "We", "also", "SYNCID", "here", "to", "be", "sure", "(", "does", "n't", "matter", "in", "the", "simulator", ",", "but", "some", "day", "it", "will", ")", "." ]

[ "mmix", "0", "2", "2", "3", "0", "1" ]

[]

[ "<s>", "static", "void", "push_minipool_fix", "(", "rtx", "insn", ",", "HOST_WIDE_INT", "address", ",", "rtx", "*", "loc", ",", "enum", "machine_mode", "mode", ",", "rtx", "value", ")", "{", "Mfix", "*", "fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "fix", ")", ")", ";", "if", "(", "flag_pic", "&&", "GET_CODE", "(", "value", ")", "==", "SYMBOL_REF", ")", "value", "=", "aof_pic_entry", "(", "value", ")", ";", "fix", "->", "insn", "=", "insn", ";", "fix", "->", "address", "=", "address", ";", "fix", "->", "loc", "=", "loc", ";", "fix", "->", "mode", "=", "mode", ";", "fix", "->", "fix_size", "=", "MINIPOOL_FIX_SIZE", "(", "mode", ")", ";", "fix", "->", "value", "=", "value", ";", "fix", "->", "forwards", "=", "get_attr_pool_range", "(", "insn", ")", ";", "fix", "->", "backwards", "=", "get_attr_neg_pool_range", "(", "insn", ")", ";", "fix", "->", "minipool", "=", "NULL", ";", "gcc_assert", "(", "fix", "->", "forwards", "||", "fix", "->", "backwards", ")", ";", "if", "(", "ARM_DOUBLEWORD_ALIGN", "&&", "fix", "->", "fix_size", "==", "8", ")", "fix", "->", "forwards", "-=", "4", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; %smode fixup for i%d; addr %lu, range (%ld,%ld): \"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "INSN_UID", "(", "insn", ")", ",", "(", "unsigned", "long", ")", "address", ",", "-", "1", "*", "(", "long", ")", "fix", "->", "backwards", ",", "(", "long", ")", "fix", "->", "forwards", ")", ";", "arm_print_value", "(", "dump_file", ",", "fix", "->", "value", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "fix", "->", "next", "=", "NULL", ";", "if", "(", "minipool_fix_head", "!=", "NULL", ")", "minipool_fix_tail", "->", "next", "=", "fix", ";", "else", "minipool_fix_head", "=", "fix", ";", "minipool_fix_tail", "=", "fix", ";", "}", "</s>" ]

[ "Record", "INSN", ",", "which", "will", "need", "fixing", "up", "to", "load", "a", "value", "from", "the", "minipool", ".", "ADDRESS", "is", "the", "offset", "of", "the", "insn", "since", "the", "start", "of", "the", "function", ";", "LOC", "is", "a", "pointer", "to", "the", "part", "of", "the", "insn", "which", "requires", "fixing", ";", "VALUE", "is", "the", "constant", "that", "must", "be", "loaded", ",", "which", "is", "of", "type", "MODE", "." ]

[ "arm", "8", "4", "\";; %smode fixup for i%d; addr %lu, range (%ld,%ld): \"", "1", "\"\\n\"" ]

[]

[ "<s>", "void", "csky_set_eh_return_address", "(", "rtx", "source", ",", "rtx", "scratch", ")", "{", "HOST_WIDE_INT", "delta", "=", "0", ";", "rtx", "basereg", ",", "addr", ";", "unsigned", "int", "reg_mask", ";", "csky_layout_stack_frame", "(", ")", ";", "reg_mask", "=", "cfun", "->", "machine", "->", "reg_mask", ";", "if", "(", "reg_mask", "&", "(", "1", "<<", "CSKY_LR_REGNUM", ")", ")", "{", "int", "i", "=", "0", ";", "if", "(", "frame_pointer_needed", ")", "{", "basereg", "=", "hard_frame_pointer_rtx", ";", "delta", "=", "0", ";", "}", "else", "{", "basereg", "=", "stack_pointer_rtx", ";", "delta", "=", "cfun", "->", "machine", "->", "reg_offset", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "CSKY_LR_REGNUM", ";", "i", "++", ")", "if", "(", "reg_mask", "&", "(", "1", "<<", "i", ")", ")", "delta", "+=", "4", ";", "if", "(", "(", "CSKY_TARGET_ARCH", "(", "CK801", ")", "&&", "delta", ">=", "CSKY_LD16_MAX_OFFSET", "(", "Pmode", ")", ")", "||", "delta", ">=", "CSKY_LD32_MAX_OFFSET", "(", "Pmode", ")", ")", "{", "emit_insn", "(", "gen_movsi", "(", "scratch", ",", "GEN_INT", "(", "delta", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "scratch", ",", "scratch", ",", "basereg", ")", ")", ";", "addr", "=", "scratch", ";", "}", "else", "addr", "=", "plus_constant", "(", "Pmode", ",", "basereg", ",", "delta", ")", ";", "emit_move_insn", "(", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ",", "source", ")", ";", "}", "else", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "CSKY_LR_REGNUM", ")", ",", "source", ")", ";", "}", "</s>" ]

[ "Helper", "for", "csky_eh_return", "splitter", ":", "store", "the", "call", "frame", "exception", "handler", "address", "in", "lr", "." ]

[ "csky", "0", "1", "0", "0", "0", "1", "4" ]

[]

[ "<s>", "virtual", "const", "PPCInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "mulsidi3_gen_fn", "mips_mulsidi3_gen_fn", "(", "enum", "rtx_code", "ext_code", ")", "{", "bool", "signed_p", ";", "signed_p", "=", "ext_code", "==", "SIGN_EXTEND", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "ISA_HAS_R6DMUL", ")", "return", "signed_p", "?", "gen_mulsidi3_64bit_r6dmul", ":", "NULL", ";", "if", "(", "ISA_HAS_DMUL3", ")", "return", "signed_p", "?", "gen_mulsidi3_64bit_dmul", ":", "NULL", ";", "if", "(", "TARGET_MIPS16", ")", "return", "(", "signed_p", "?", "gen_mulsidi3_64bit_mips16", ":", "gen_umulsidi3_64bit_mips16", ")", ";", "if", "(", "TARGET_FIX_R4000", ")", "return", "NULL", ";", "return", "signed_p", "?", "gen_mulsidi3_64bit", ":", "gen_umulsidi3_64bit", ";", "}", "else", "{", "if", "(", "ISA_HAS_R6MUL", ")", "return", "(", "signed_p", "?", "gen_mulsidi3_32bit_r6", ":", "gen_umulsidi3_32bit_r6", ")", ";", "if", "(", "TARGET_MIPS16", ")", "return", "(", "signed_p", "?", "gen_mulsidi3_32bit_mips16", ":", "gen_umulsidi3_32bit_mips16", ")", ";", "if", "(", "TARGET_FIX_R4000", "&&", "!", "ISA_HAS_DSP", ")", "return", "signed_p", "?", "gen_mulsidi3_32bit_r4000", ":", "gen_umulsidi3_32bit_r4000", ";", "return", "signed_p", "?", "gen_mulsidi3_32bit", ":", "gen_umulsidi3_32bit", ";", "}", "}", "</s>" ]

[ "Return", "the", "function", "that", "is", "used", "to", "expand", "the", "<", "u", ">", "mulsidi3", "pattern", ".", "EXT_CODE", "is", "the", "code", "of", "the", "extension", "used", ".", "Return", "NULL", "if", "widening", "multiplication", "should", "n't", "be", "used", "." ]

[ "mips" ]

[]

[ "<s>", "static", "void", "frv_frame_access", "(", "frv_frame_accessor_t", "*", "accessor", ",", "rtx", "reg", ",", "int", "stack_offset", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "rtx", "mem", "=", "frv_frame_mem", "(", "mode", ",", "accessor", "->", "base", ",", "stack_offset", "-", "accessor", "->", "base_offset", ")", ";", "if", "(", "accessor", "->", "op", "==", "FRV_LOAD", ")", "{", "if", "(", "SPR_P", "(", "REGNO", "(", "reg", ")", ")", ")", "{", "rtx", "temp", "=", "gen_rtx_REG", "(", "mode", ",", "TEMP_REGNO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "mem", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "temp", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ")", ";", "emit_insn", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ")", ";", "}", "else", "{", "if", "(", "SPR_P", "(", "REGNO", "(", "reg", ")", ")", ")", "{", "rtx", "temp", "=", "gen_rtx_REG", "(", "mode", ",", "TEMP_REGNO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "reg", ")", ")", ";", "frv_frame_insn", "(", "gen_rtx_SET", "(", "Pmode", ",", "mem", ",", "temp", ")", ",", "frv_dwarf_store", "(", "reg", ",", "stack_offset", ")", ")", ";", "}", "else", "if", "(", "GET_MODE", "(", "reg", ")", "==", "DImode", ")", "{", "rtx", "reg1", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "reg", ")", ")", ";", "rtx", "reg2", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "reg", ")", "+", "1", ")", ";", "rtx", "set1", "=", "frv_dwarf_store", "(", "reg1", ",", "stack_offset", ")", ";", "rtx", "set2", "=", "frv_dwarf_store", "(", "reg2", ",", "stack_offset", "+", "4", ")", ";", "frv_frame_insn", "(", "gen_rtx_SET", "(", "Pmode", ",", "mem", ",", "reg", ")", ",", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set1", ",", "set2", ")", ")", ")", ";", "}", "else", "frv_frame_insn", "(", "gen_rtx_SET", "(", "Pmode", ",", "mem", ",", "reg", ")", ",", "frv_dwarf_store", "(", "reg", ",", "stack_offset", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "instructions", "that", "transfer", "REG", "to", "or", "from", "the", "memory", "location", "(", "sp", "+", "STACK_OFFSET", ")", ".", "The", "register", "is", "stored", "in", "memory", "if", "ACCESSOR-", ">", "OP", "is", "FRV_STORE", "and", "loaded", "if", "it", "is", "FRV_LOAD", ".", "Only", "the", "prologue", "uses", "this", "function", "to", "store", "registers", "and", "only", "the", "epilogue", "uses", "it", "to", "load", "them", ".", "The", "caller", "sets", "up", "ACCESSOR", "so", "that", "BASE", "is", "equal", "to", "(", "sp", "+", "BASE_OFFSET", ")", ".", "The", "generated", "instruction", "will", "use", "BASE", "as", "its", "base", "register", ".", "BASE", "may", "simply", "be", "the", "stack", "pointer", ",", "but", "if", "several", "accesses", "are", "being", "made", "to", "a", "region", "far", "away", "from", "the", "stack", "pointer", ",", "it", "may", "be", "more", "efficient", "to", "set", "up", "a", "temporary", "instead", ".", "Store", "instructions", "will", "be", "frame-related", "and", "will", "be", "annotated", "with", "the", "overall", "effect", "of", "the", "store", ".", "Load", "instructions", "will", "be", "followed", "by", "a", "(", "use", ")", "to", "prevent", "later", "optimizations", "from", "zapping", "them", ".", "The", "function", "takes", "care", "of", "the", "moves", "to", "and", "from", "SPRs", ",", "using", "TEMP_REGNO", "as", "a", "temporary", "in", "such", "cases", "." ]

[ "frv", "1", "4", "2" ]

[]

[ "<s>", "DecodeStatus", "DLXDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", ",", "raw_ostream", "&", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableDLX32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "PostOperandDecodeAdjust", "(", "Instr", ",", "Insn", ")", ";", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "DLX", "DLX", "DLX", "4" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "AArch64", "AArch64", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "static", "bool", "tilegx_tls_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "contains", "a", "thread-local", "symbol", "." ]

[ "tilegx", "0", "0", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "Align", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "{", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "*", "Fast", "=", "true", ";", "break", ";", "case", "128", ":", "*", "Fast", "=", "!", "Subtarget", ".", "isUnalignedMem16Slow", "(", ")", ";", "break", ";", "case", "256", ":", "*", "Fast", "=", "!", "Subtarget", ".", "isUnalignedMem32Slow", "(", ")", ";", "break", ";", "}", "}", "if", "(", "!", "!", "(", "Flags", "&", "MachineMemOperand", "::", "MONonTemporal", ")", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "!", "!", "(", "Flags", "&", "MachineMemOperand", "::", "MOLoad", ")", ")", "return", "(", "Alignment", "<", "16", "||", "!", "Subtarget", ".", "hasSSE41", "(", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "X86", "X86", "128", "256", "16" ]

[]

[ "<s>", "rtx", "function_expander", "::", "get_reg_target", "(", ")", "{", "machine_mode", "target_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ";", "if", "(", "!", "possible_target", "||", "GET_MODE", "(", "possible_target", ")", "!=", "target_mode", ")", "possible_target", "=", "gen_reg_rtx", "(", "target_mode", ")", ";", "return", "possible_target", ";", "}", "</s>" ]

[ "Return", "a", "REG", "rtx", "that", "can", "be", "used", "for", "the", "result", "of", "the", "function", ",", "using", "the", "preferred", "target", "if", "suitable", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "bool", "doMergeWithPrevious", ")", "const", "{", "if", "(", "(", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "doMergeWithPrevious", "?", "std", "::", "prev", "(", "MBBI", ")", ":", "MBBI", ";", "MachineBasicBlock", "::", "iterator", "NI", "=", "doMergeWithPrevious", "?", "nullptr", ":", "std", "::", "next", "(", "MBBI", ")", ";", "PI", "=", "skipDebugInstructionsBackward", "(", "PI", ",", "MBB", ".", "begin", "(", ")", ")", ";", "if", "(", "NI", "!=", "nullptr", ")", "NI", "=", "skipDebugInstructionsForward", "(", "NI", ",", "MBB", ".", "end", "(", ")", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "!", "doMergeWithPrevious", "&&", "NI", "!=", "MBB", ".", "end", "(", ")", "&&", "NI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", "{", "return", "Offset", ";", "}", "if", "(", "(", "Opc", "==", "X86", "::", "ADD64ri32", "||", "Opc", "==", "X86", "::", "ADD64ri8", "||", "Opc", "==", "X86", "::", "ADD32ri", "||", "Opc", "==", "X86", "::", "ADD32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "+=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "LEA32r", "||", "Opc", "==", "X86", "::", "LEA64_32r", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "1", "&&", "PI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", "&&", "PI", "->", "getOperand", "(", "5", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", ")", "{", "Offset", "+=", "PI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "SUB64ri32", "||", "Opc", "==", "X86", "::", "SUB64ri8", "||", "Opc", "==", "X86", "::", "SUB32ri", "||", "Opc", "==", "X86", "::", "SUB32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "-=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "return", "Offset", ";", "}", "</s>" ]

[ "Check", "the", "instruction", "before/after", "the", "passed", "instruction", "." ]

[ "X86", "X86", "0", "0", "X86::ADD64ri32", "X86::ADD64ri8", "X86::ADD32ri", "X86::ADD32ri8", "0", "1", "2", "X86::LEA32r", "X86::LEA64_32r", "0", "1", "2", "1", "3", "X86::NoRegister", "5", "X86::NoRegister", "4", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "0", "1", "2" ]

[]

[ "<s>", "void", "BPFPassConfig", "::", "addPreEmitPass", "(", ")", "{", "const", "BPFSubtarget", "*", "Subtarget", "=", "getBPFTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "if", "(", "Subtarget", "->", "getHasAlu32", "(", ")", "&&", "!", "DisableMIPeephole", ")", "addPass", "(", "createBPFMIPreEmitPeepholePass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "BPF", "BPF", "BPF", "BPF", "BPF" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Subtarget", "->", "requiresStrictAlign", "(", ")", ")", "return", "false", ";", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "rtx", "mmix_function_arg_1", "(", "const", "cumulative_args_t", "argsp_v", ",", "const", "function_arg_info", "&", "arg", ",", "bool", "incoming", ")", "{", "CUMULATIVE_ARGS", "*", "argsp", "=", "get_cumulative_args", "(", "argsp_v", ")", ";", "machine_mode", "mode", "=", "arg", ".", "mode", "==", "VOIDmode", "?", "DImode", ":", "arg", ".", "mode", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "(", "argsp", "->", "regs", "<", "MMIX_MAX_ARGS_IN_REGS", ")", "?", "gen_rtx_REG", "(", "mode", ",", "(", "incoming", "?", "MMIX_FIRST_INCOMING_ARG_REGNUM", ":", "MMIX_FIRST_ARG_REGNUM", ")", "+", "argsp", "->", "regs", ")", ":", "NULL_RTX", ";", "return", "(", "argsp", "->", "regs", "<", "MMIX_MAX_ARGS_IN_REGS", "&&", "!", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", "&&", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "64", "||", "argsp", "->", "lib", "||", "TARGET_LIBFUNC", ")", ")", "?", "gen_rtx_REG", "(", "mode", ",", "(", "incoming", "?", "MMIX_FIRST_INCOMING_ARG_REGNUM", ":", "MMIX_FIRST_ARG_REGNUM", ")", "+", "argsp", "->", "regs", ")", ":", "NULL_RTX", ";", "}", "</s>" ]

[ "Helper", "function", "for", "mmix_function_arg", "and", "mmix_function_incoming_arg", "." ]

[ "mmix", "64" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MBB", ".", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int", "BOpc", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "B", ":", "(", "AFI", "->", "isThumb2Function", "(", ")", "?", "ARM", "::", "t2B", ":", "ARM", "::", "tB", ")", ";", "int", "BccOpc", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "Bcc", ":", "(", "AFI", "->", "isThumb2Function", "(", ")", "?", "ARM", "::", "t2Bcc", ":", "ARM", "::", "tBcc", ")", ";", "bool", "isThumb", "=", "AFI", "->", "isThumbFunction", "(", ")", "||", "AFI", "->", "isThumb2Function", "(", ")", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "2", "||", "Cond", ".", "size", "(", ")", "==", "0", "||", "Cond", ".", "size", "(", ")", "==", "3", ")", "&&", "\"ARM branch conditions have two or three components!\"", ")", ";", "if", "(", "!", "FBB", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "if", "(", "isThumb", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BOpc", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BOpc", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "else", "if", "(", "Cond", ".", "size", "(", ")", "==", "2", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BccOpc", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "if", "(", "Cond", ".", "size", "(", ")", "==", "2", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BccOpc", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "else", "if", "(", "Cond", ".", "size", "(", ")", "==", "3", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "isThumb", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BOpc", ")", ")", ".", "addMBB", "(", "FBB", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BOpc", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "ARM", "ARM", "\"code size not handled\"", "ARM", "ARM", "ARM::B", "ARM::t2B", "ARM::tB", "ARM::Bcc", "ARM::t2Bcc", "ARM::tBcc", "\"insertBranch must not be told to insert a fallthrough\"", "2", "0", "3", "\"ARM branch conditions have two or three components!\"", "ARMCC::AL", "2", "0", "1", "0", "1", "1", "2", "0", "1", "3", "0", "1", "ARMCC::AL", "2" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LiveVariables", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveVariables", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "inline", "bool", "inline_secondary_memory_needed", "(", "machine_mode", "mode", ",", "reg_class_t", "class1", ",", "reg_class_t", "class2", ",", "int", "strict", ")", "{", "if", "(", "lra_in_progress", "&&", "(", "class1", "==", "NO_REGS", "||", "class2", "==", "NO_REGS", ")", ")", "return", "false", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class1", ")", "||", "MAYBE_FLOAT_CLASS_P", "(", "class2", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class1", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class2", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class1", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class2", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", "||", "MAYBE_MASK_CLASS_P", "(", "class1", ")", "!=", "MASK_CLASS_P", "(", "class1", ")", "||", "MAYBE_MASK_CLASS_P", "(", "class2", ")", "!=", "MASK_CLASS_P", "(", "class2", ")", ")", "{", "gcc_assert", "(", "!", "strict", "||", "lra_in_progress", ")", ";", "return", "true", ";", "}", "if", "(", "FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "MASK_CLASS_P", "(", "class1", ")", "!=", "MASK_CLASS_P", "(", "class2", ")", ")", "{", "if", "(", "!", "(", "INTEGER_CLASS_P", "(", "class1", ")", "||", "INTEGER_CLASS_P", "(", "class2", ")", ")", "||", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "true", ";", "}", "if", "(", "SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", ")", "{", "if", "(", "!", "TARGET_SSE2", ")", "return", "true", ";", "if", "(", "!", "(", "INTEGER_CLASS_P", "(", "class1", ")", "||", "INTEGER_CLASS_P", "(", "class2", ")", ")", ")", "return", "true", ";", "int", "msize", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "msize", ">", "UNITS_PER_WORD", ")", "return", "true", ";", "int", "minsize", "=", "GET_MODE_SIZE", "(", "TARGET_SSE2", "?", "HImode", ":", "SImode", ")", ";", "if", "(", "msize", "<", "minsize", ")", "return", "true", ";", "if", "(", "(", "SSE_CLASS_P", "(", "class1", ")", "&&", "!", "TARGET_INTER_UNIT_MOVES_FROM_VEC", ")", "||", "(", "SSE_CLASS_P", "(", "class2", ")", "&&", "!", "TARGET_INTER_UNIT_MOVES_TO_VEC", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "we", "are", "copying", "between", "general", "and", "FP", "registers", ",", "we", "need", "a", "memory", "location", ".", "The", "same", "is", "true", "for", "SSE", "and", "MMX", "registers", ".", "To", "optimize", "register_move_cost", "performance", ",", "allow", "inline", "variant", ".", "The", "macro", "ca", "n't", "work", "reliably", "when", "one", "of", "the", "CLASSES", "is", "class", "containing", "registers", "from", "multiple", "units", "(", "SSE", ",", "MMX", ",", "integer", ")", ".", "We", "avoid", "this", "by", "never", "combining", "those", "units", "in", "single", "alternative", "in", "the", "machine", "description", ".", "Ensure", "that", "this", "constraint", "holds", "to", "avoid", "unexpected", "surprises", ".", "When", "STRICT", "is", "false", ",", "we", "are", "being", "called", "from", "REGISTER_MOVE_COST", ",", "so", "do", "not", "enforce", "these", "sanity", "checks", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "visitInstruction", "(", "Instruction", "&", "I", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Specify", "what", "to", "return", "for", "unhandled", "instructions", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "&", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "TII", "->", "isVOP3", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "TII", "->", "legalizeOperandsVOP3", "(", "MRI", ",", "MI", ")", ";", "if", "(", "MI", ".", "getDesc", "(", ")", ".", "OpInfo", ")", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "I", ":", "{", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ",", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", "}", ")", "{", "if", "(", "I", "==", "-", "1", ")", "break", ";", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "continue", ";", "auto", "*", "RC", "=", "TRI", "->", "getRegClassForReg", "(", "MRI", ",", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "TRI", "->", "hasAGPRs", "(", "RC", ")", ")", "continue", ";", "auto", "*", "Src", "=", "MRI", ".", "getUniqueVRegDef", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "Src", "||", "!", "Src", "->", "isCopy", "(", ")", "||", "!", "TRI", "->", "isSGPRReg", "(", "MRI", ",", "Src", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "continue", ";", "auto", "*", "NewRC", "=", "TRI", "->", "getEquivalentVGPRClass", "(", "RC", ")", ";", "MRI", ".", "setRegClass", "(", "Op", ".", "getReg", "(", ")", ",", "NewRC", ")", ";", "}", "if", "(", "auto", "*", "Src2", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ")", "{", "if", "(", "Src2", "->", "isReg", "(", ")", "&&", "Src2", "->", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "{", "auto", "*", "RC", "=", "TRI", "->", "getRegClassForReg", "(", "MRI", ",", "Src2", "->", "getReg", "(", ")", ")", ";", "if", "(", "TRI", "->", "isVectorSuperClass", "(", "RC", ")", ")", "{", "auto", "*", "NewRC", "=", "TRI", "->", "getEquivalentAGPRClass", "(", "RC", ")", ";", "MRI", ".", "setRegClass", "(", "Src2", "->", "getReg", "(", ")", ",", "NewRC", ")", ";", "if", "(", "Src2", "->", "isTied", "(", ")", ")", "MRI", ".", "setRegClass", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "NewRC", ")", ";", "}", "}", "}", "}", "return", ";", "}", "if", "(", "TII", "->", "isMIMG", "(", "MI", ")", ")", "{", "if", "(", "!", "MI", ".", "mayStore", "(", ")", ")", "AddIMGInit", "(", "MI", ")", ";", "TII", "->", "enforceOperandRCAlignment", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'hasPostISelHook", "'", "flag", "." ]

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "1", "AMDGPU::OpName", "0", "AMDGPU::OpName" ]

[]

[ "<s>", "void", "rs6000_expand_extract_even", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "unsigned", "i", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "rtx", "perm", "[", "16", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "perm", "[", "i", "]", "=", "GEN_INT", "(", "i", "*", "2", ")", ";", "rs6000_do_expand_vec_perm", "(", "target", ",", "op0", ",", "op1", ",", "vmode", ",", "nelt", ",", "perm", ")", ";", "}", "</s>" ]

[ "Expand", "an", "extract", "even", "operation", "." ]

[ "rs6000", "16", "0", "2" ]

[]

[ "<s>", "MachineSDNode", "*", "SITargetLowering", "::", "buildRSRC", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Ptr", ",", "uint32_t", "RsrcDword1", ",", "uint64_t", "RsrcDword2And3", ")", "const", "{", "SDValue", "PtrLo", "=", "DAG", ".", "getTargetExtractSubreg", "(", "AMDGPU", "::", "sub0", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ")", ";", "SDValue", "PtrHi", "=", "DAG", ".", "getTargetExtractSubreg", "(", "AMDGPU", "::", "sub1", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ")", ";", "if", "(", "RsrcDword1", ")", "{", "PtrHi", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "AMDGPU", "::", "S_OR_B32", ",", "DL", ",", "MVT", "::", "i32", ",", "PtrHi", ",", "DAG", ".", "getConstant", "(", "RsrcDword1", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "SDValue", "DataLo", "=", "buildSMovImm32", "(", "DAG", ",", "DL", ",", "RsrcDword2And3", "&", "UINT64_C", "(", "0xFFFFFFFF", ")", ")", ";", "SDValue", "DataHi", "=", "buildSMovImm32", "(", "DAG", ",", "DL", ",", "RsrcDword2And3", ">>", "32", ")", ";", "const", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "SReg_128RegClassID", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "PtrLo", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub0", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "PtrHi", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub1", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DataLo", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub2", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DataHi", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub3", ",", "DL", ",", "MVT", "::", "i32", ")", "}", ";", "return", "DAG", ".", "getMachineNode", "(", "AMDGPU", "::", "REG_SEQUENCE", ",", "DL", ",", "MVT", "::", "v4i32", ",", "Ops", ")", ";", "}", "</s>" ]

[ "Return", "a", "resource", "descriptor", "with", "the", "'Add", "TID", "'", "bit", "enabled", "The", "TID", "(", "Thread", "ID", ")", "is", "multiplied", "by", "the", "stride", "value", "(", "bits", "[", "61:48", "]", "of", "the", "resource", "descriptor", ")", "to", "create", "an", "offset", ",", "which", "is", "added", "to", "the", "resource", "pointer", "." ]

[ "AMDGPU", "SI", "AMDGPU::sub0", "MVT::i32", "AMDGPU::sub1", "MVT::i32", "AMDGPU::S_OR_B32", "MVT::i32", "MVT::i32", "0", "0xFFFFFFFF", "32", "AMDGPU::SReg_128RegClassID", "MVT::i32", "AMDGPU::sub0", "MVT::i32", "AMDGPU::sub1", "MVT::i32", "AMDGPU::sub2", "MVT::i32", "AMDGPU::sub3", "MVT::i32", "AMDGPU::REG_SEQUENCE", "MVT::v4i32" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"VideoCore4 Assembly Printer\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "VideoCore4", "\"VideoCore4 Assembly Printer\"" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "SITargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "RMW", ")", "const", "{", "switch", "(", "RMW", "->", "getOperation", "(", ")", ")", "{", "case", "AtomicRMWInst", "::", "FAdd", ":", "{", "Type", "*", "Ty", "=", "RMW", "->", "getType", "(", ")", ";", "if", "(", "Ty", "->", "isHalfTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "!", "Ty", "->", "isFloatTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "AS", "=", "RMW", "->", "getPointerAddressSpace", "(", ")", ";", "return", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "Subtarget", "->", "hasLDSFPAtomics", "(", ")", ")", "?", "AtomicExpansionKind", "::", "None", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "default", ":", "break", ";", "}", "return", "AMDGPUTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "RMW", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "ARMELFStreamer", "::", "Reset", "(", ")", "{", "ExTab", "=", "NULL", ";", "FnStart", "=", "NULL", ";", "Personality", "=", "NULL", ";", "CantUnwind", "=", "false", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "thumb2_expand_return", "(", "bool", "simple_return", ")", "{", "int", "i", ",", "num_regs", ";", "unsigned", "long", "saved_regs_mask", ";", "arm_stack_offsets", "*", "offsets", ";", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "saved_regs_mask", "=", "offsets", "->", "saved_regs_mask", ";", "for", "(", "i", "=", "0", ",", "num_regs", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "if", "(", "saved_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "if", "(", "!", "simple_return", "&&", "saved_regs_mask", ")", "{", "if", "(", "num_regs", "==", "1", ")", "{", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "PC_REGNUM", ")", ";", "rtx", "addr", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "SImode", ",", "stack_pointer_rtx", ")", ")", ";", "set_mem_alias_set", "(", "addr", ",", "get_frame_alias_set", "(", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "ret_rtx", ";", "XVECEXP", "(", "par", ",", "0", ",", "1", ")", "=", "gen_rtx_SET", "(", "SImode", ",", "reg", ",", "addr", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "par", ",", "0", ",", "1", ")", ")", "=", "1", ";", "emit_jump_insn", "(", "par", ")", ";", "}", "else", "{", "saved_regs_mask", "&=", "~", "(", "1", "<<", "LR_REGNUM", ")", ";", "saved_regs_mask", "|=", "(", "1", "<<", "PC_REGNUM", ")", ";", "arm_emit_multi_reg_pop", "(", "saved_regs_mask", ")", ";", "}", "}", "else", "{", "emit_jump_insn", "(", "simple_return_rtx", ")", ";", "}", "}", "</s>" ]

[ "Generate", "pattern", "*", "pop_multiple_with_stack_update_and_return", "if", "single", "POP", "instruction", "can", "be", "generated", ".", "LR", "should", "be", "replaced", "by", "PC", ".", "All", "the", "checks", "required", "are", "already", "done", "by", "USE_RETURN_INSN", "(", ")", ".", "Hence", ",", "all", "we", "really", "need", "to", "check", "here", "is", "if", "single", "register", "is", "to", "be", "returned", ",", "or", "multiple", "register", "return", "." ]

[ "arm", "0", "0", "1", "1", "2", "0", "0", "0", "1", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "void", "BPFInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "BPF", "::", "GPRRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BPF", "::", "STD", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "BPF", "BPF", "BPF::GPRRegClass", "BPF::STD", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "void", "mips_expand_scc", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "target", "=", "operands", "[", "0", "]", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "2", "]", ";", "rtx", "op1", "=", "operands", "[", "3", "]", ";", "gcc_assert", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "op0", ")", ")", "==", "MODE_INT", ")", ";", "if", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", "{", "if", "(", "ISA_HAS_SEQ_SNE", "&&", "reg_imm10_operand", "(", "op1", ",", "GET_MODE", "(", "op1", ")", ")", ")", "mips_emit_binary", "(", "code", ",", "target", ",", "op0", ",", "op1", ")", ";", "else", "{", "rtx", "zie", "=", "mips_zero_if_equal", "(", "op0", ",", "op1", ")", ";", "mips_emit_binary", "(", "code", ",", "target", ",", "zie", ",", "const0_rtx", ")", ";", "}", "}", "else", "mips_emit_int_order_test", "(", "code", ",", "0", ",", "target", ",", "op0", ",", "op1", ")", ";", "}", "</s>" ]

[ "Try", "performing", "the", "comparison", "in", "OPERANDS", "[", "1", "]", ",", "whose", "arms", "are", "OPERANDS", "[", "2", "]", "and", "OPERAND", "[", "3", "]", ".", "Store", "the", "result", "in", "OPERANDS", "[", "0", "]", ".", "On", "64-bit", "targets", ",", "the", "mode", "of", "the", "comparison", "and", "target", "will", "always", "be", "SImode", ",", "thus", "possibly", "narrower", "than", "that", "of", "the", "comparison", "'s", "operands", "." ]

[ "mips", "0", "1", "2", "3", "0" ]

[]

[ "<s>", "Value", "*", "HexagonTargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "BasicBlock", "*", "BB", "=", "Builder", ".", "GetInsertBlock", "(", ")", ";", "Module", "*", "M", "=", "BB", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "PT", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", ";", "Type", "*", "Ty", "=", "PT", "->", "getElementType", "(", ")", ";", "unsigned", "SZ", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "assert", "(", "(", "SZ", "==", "32", "||", "SZ", "==", "64", ")", "&&", "\"Only 32/64-bit atomic loads supported\"", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "(", "SZ", "==", "32", ")", "?", "Intrinsic", "::", "hexagon_L2_loadw_locked", ":", "Intrinsic", "::", "hexagon_L4_loadd_locked", ";", "Function", "*", "Fn", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "IntID", ")", ";", "PointerType", "*", "NewPtrTy", "=", "Builder", ".", "getIntNTy", "(", "SZ", ")", "->", "getPointerTo", "(", "PT", "->", "getAddressSpace", "(", ")", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "NewPtrTy", ")", ";", "Value", "*", "Call", "=", "Builder", ".", "CreateCall", "(", "Fn", ",", "Addr", ",", "\"larx\"", ")", ";", "return", "Builder", ".", "CreateBitCast", "(", "Call", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "Hexagon", "Hexagon", "32", "64", "\"Only 32/64-bit atomic loads supported\"", "Intrinsic::ID", "32", "Intrinsic::hexagon_L2_loadw_locked", "Intrinsic::hexagon_L4_loadd_locked", "Intrinsic::getDeclaration", "\"larx\"" ]

[]

[ "<s>", "void", "SparcPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSparcDelaySlotFillerPass", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "insertNOPLoad", "(", ")", ")", "{", "addPass", "(", "new", "InsertNOPLoad", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "device", "(", ")", "->", "getGeneration", "(", ")", ">", "AMDGPUDeviceInfo", "::", "HD6XXX", ")", "{", "addPass", "(", "createAMDGPUStructurizeCFGPass", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "R600", "AMDGPUDeviceInfo::HD6XXX", "SI" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "PPCSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "hasVSX", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "initialize", "(", "MF", ")", ";", "if", "(", "gatherVectorInstructions", "(", ")", ")", "{", "formWebs", "(", ")", ";", "recordUnoptimizableWebs", "(", ")", ";", "markSwapsForRemoval", "(", ")", ";", "Changed", "=", "removeSwaps", "(", ")", ";", "}", "delete", "EC", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "static", "void", "frv_align_label", "(", "void", ")", "{", "unsigned", "int", "alignment", ",", "target", ",", "nop", ";", "rtx_insn", "*", "x", ",", "*", "last", ",", "*", "barrier", ",", "*", "label", ";", "last", "=", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "-", "1", "]", ";", "label", "=", "barrier", "=", "0", ";", "alignment", "=", "4", ";", "for", "(", "x", "=", "NEXT_INSN", "(", "last", ")", ";", "x", "!=", "0", "&&", "!", "INSN_P", "(", "x", ")", ";", "x", "=", "NEXT_INSN", "(", "x", ")", ")", "{", "if", "(", "LABEL_P", "(", "x", ")", ")", "{", "unsigned", "int", "subalign", "=", "1", "<<", "label_to_alignment", "(", "x", ")", ";", "alignment", "=", "MAX", "(", "alignment", ",", "subalign", ")", ";", "label", "=", "x", ";", "}", "if", "(", "BARRIER_P", "(", "x", ")", ")", "barrier", "=", "x", ";", "}", "if", "(", "TARGET_ALIGN_LABELS", "&&", "label", "!=", "0", "&&", "barrier", "==", "0", "&&", "frv_packet", ".", "num_insns", "<", "frv_packet", ".", "issue_rate", ")", "alignment", "=", "MAX", "(", "alignment", ",", "8", ")", ";", "frv_packet_address", "+=", "frv_packet", ".", "num_insns", "*", "4", ";", "target", "=", "(", "frv_packet_address", "+", "alignment", "-", "1", ")", "&", "-", "alignment", ";", "if", "(", "barrier", "==", "0", ")", "{", "for", "(", "nop", "=", "0", ";", "nop", "<", "frv_num_nops", ";", "nop", "++", ")", "while", "(", "frv_packet_address", "<", "target", "&&", "frv_pack_insn_p", "(", "frv_nops", "[", "nop", "]", ")", ")", "{", "frv_insert_nop_in_packet", "(", "frv_nops", "[", "nop", "]", ")", ";", "frv_packet_address", "+=", "4", ";", "}", "last", "=", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "-", "1", "]", ";", "nop", "=", "0", ";", "while", "(", "frv_packet_address", "<", "target", ")", "{", "last", "=", "emit_insn_after", "(", "PATTERN", "(", "frv_nops", "[", "nop", "]", ")", ",", "last", ")", ";", "frv_packet_address", "+=", "4", ";", "if", "(", "frv_num_nops", ">", "1", ")", "nop", "^=", "1", ";", "}", "}", "frv_packet_address", "=", "target", ";", "}", "</s>" ]

[ "If", "the", "current", "packet", "falls", "through", "to", "a", "label", ",", "try", "to", "pad", "the", "packet", "with", "nops", "in", "order", "to", "fit", "the", "label", "'s", "alignment", "requirements", "." ]

[ "frv", "1", "0", "4", "0", "1", "0", "0", "8", "4", "1", "0", "0", "4", "1", "0", "4", "1", "1" ]

[]

[ "<s>", "static", "tree", "rs6000_d_handle_target_object_format", "(", "void", ")", "{", "const", "char", "*", "objfmt", "=", "NULL", ";", "if", "(", "TARGET_ELF", ")", "objfmt", "=", "\"elf\"", ";", "else", "if", "(", "TARGET_MACHO", ")", "objfmt", "=", "\"macho\"", ";", "else", "if", "(", "TARGET_XCOFF", ")", "objfmt", "=", "\"coff\"", ";", "if", "(", "objfmt", "==", "NULL", ")", "return", "NULL_TREE", ";", "return", "build_string_literal", "(", "strlen", "(", "objfmt", ")", "+", "1", ",", "objfmt", ")", ";", "}", "</s>" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "objectFormat", "''", ")", "'", "." ]

[ "rs6000", "\"elf\"", "\"macho\"", "\"coff\"", "1" ]

[]

[ "<s>", "static", "void", "ix86_add_queued_cfa_restore_notes", "(", "rtx", "insn", ")", "{", "rtx", "last", ";", "if", "(", "!", "queued_cfa_restores", ")", "return", ";", "for", "(", "last", "=", "queued_cfa_restores", ";", "XEXP", "(", "last", ",", "1", ")", ";", "last", "=", "XEXP", "(", "last", ",", "1", ")", ")", ";", "XEXP", "(", "last", ",", "1", ")", "=", "REG_NOTES", "(", "insn", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "queued_cfa_restores", ";", "queued_cfa_restores", "=", "NULL_RTX", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Add", "queued", "REG_CFA_RESTORE", "notes", "if", "any", "to", "INSN", "." ]

[ "i386", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "rtx", "move_to_de", "(", "int", "opno", ",", "rtx", "before", ")", "{", "rtx", "src", "=", "OP", "(", "opno", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "rtx", "reg", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "recog_data", ".", "operand_mode", "[", "opno", "]", ";", "reg", "=", "(", "mode", "==", "QImode", ")", "?", "E", ":", "DE", ";", "if", "(", "mode", "==", "QImode", "||", "!", "is_virtual_register", "(", "OP", "(", "opno", ")", ")", ")", "{", "OP", "(", "opno", ")", "=", "move_to_acc", "(", "opno", ",", "before", ")", ";", "OP", "(", "opno", ")", "=", "move_acc_to_reg", "(", "OP", "(", "opno", ")", ",", "E_REG", ",", "before", ")", ";", "}", "else", "{", "gen_and_emit_move", "(", "reg", ",", "src", ",", "before", ",", "true", ")", ";", "}", "return", "reg", ";", "}", "</s>" ]

[ "Copy", "OP", "(", "opno", ")", "to", "E", "or", "DE", ",", "placing", "any", "generated", "insns", "before", "BEFORE", ".", "Returns", "E/DE", "RTX", "." ]

[ "rl78" ]

[]

[ "<s>", "const", "PPCSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "rtx", "move_from_acc", "(", "unsigned", "int", "opno", ",", "rtx", "after", ")", "{", "rtx", "dest", "=", "OP", "(", "opno", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", "<", "2", ")", "return", "dest", ";", "return", "gen_and_emit_move", "(", "dest", ",", "mode", "==", "QImode", "?", "A", ":", "AX", ",", "after", ",", "false", ")", ";", "}", "</s>" ]

[ "Copy", "accumulator", "(", "A", "or", "AX", ")", "to", "DEST", ",", "placing", "any", "generated", "insns", "after", "AFTER", ".", "Returns", "accumulator", "RTX", "." ]

[ "rl78", "2" ]

[]

[ "<s>", "bool", "MOSRegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "Register", "Reg", ")", "const", "{", "MachineIRBuilder", "Builder", "(", "MBB", ",", "I", ")", ";", "const", "MOSSubtarget", "&", "STI", "=", "Builder", ".", "getMF", "(", ")", ".", "getSubtarget", "<", "MOSSubtarget", ">", "(", ")", ";", "switch", "(", "Reg", ")", "{", "default", ":", "errs", "(", ")", "<<", "\"Register: \"", "<<", "getName", "(", "Reg", ")", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"Scavenger spill for register not yet implemented.\"", ")", ";", "case", "MOS", "::", "A", ":", "case", "MOS", "::", "Y", ":", "{", "Register", "Save", "=", "Reg", "==", "MOS", "::", "A", "?", "MOS", "::", "RC16", ":", "MOS", "::", "RC17", ";", "bool", "UseHardStack", "=", "(", "Reg", "==", "MOS", "::", "A", "||", "STI", ".", "has65C02", "(", ")", ")", "&&", "pushPullBalanced", "(", "I", ",", "UseMI", ")", ";", "if", "(", "UseHardStack", ")", "Builder", ".", "buildInstr", "(", "MOS", "::", "PH", ",", "{", "}", ",", "{", "Reg", "}", ")", ";", "else", "Builder", ".", "buildInstr", "(", "MOS", "::", "STImag8", ",", "{", "Save", "}", ",", "{", "Reg", "}", ")", ";", "Builder", ".", "setInsertPt", "(", "MBB", ",", "UseMI", ")", ";", "if", "(", "UseHardStack", ")", "Builder", ".", "buildInstr", "(", "MOS", "::", "PL", ",", "{", "Reg", "}", ",", "{", "}", ")", ";", "else", "Builder", ".", "buildInstr", "(", "MOS", "::", "LDImag8", ",", "{", "Reg", "}", ",", "{", "Save", "}", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "MOS", "MOS", "MOS", "MOS", "\"Register: \"", "\"\\n\"", "\"Scavenger spill for register not yet implemented.\"", "MOS::A", "MOS::Y", "MOS::A", "MOS::RC16", "MOS::RC17", "MOS::A", "MOS::PH", "MOS::STImag8", "MOS::PL", "MOS::LDImag8" ]

[]

[ "<s>", "int", "tls_symbolic_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "SYMBOL_REF", ")", "return", "0", ";", "return", "SYMBOL_REF_TLS_MODEL", "(", "op", ")", ";", "}", "</s>" ]

[ "Return", "the", "TLS", "type", "for", "TLS", "symbols", ",", "0", "for", "otherwise", "." ]

[ "sh", "0" ]

[]

[ "<s>", "static", "void", "rs6000_expand_vector_set_var_p9", "(", "rtx", "target", ",", "rtx", "val", ",", "rtx", "idx", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "gcc_assert", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "!", "CONST_INT_P", "(", "idx", ")", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE", "(", "val", ")", ";", "int", "width", "=", "GET_MODE_SIZE", "(", "inner_mode", ")", ";", "gcc_assert", "(", "width", ">=", "1", "&&", "width", "<=", "8", ")", ";", "int", "shift", "=", "exact_log2", "(", "width", ")", ";", "machine_mode", "idx_mode", "=", "GET_MODE", "(", "idx", ")", ";", "machine_mode", "shift_mode", ";", "rtx", "(", "*", "gen_ashl", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_pcvr1", ")", "(", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_pcvr2", ")", "(", "rtx", ",", "rtx", ")", ";", "if", "(", "TARGET_POWERPC64", ")", "{", "shift_mode", "=", "DImode", ";", "gen_ashl", "=", "gen_ashldi3", ";", "gen_pcvr1", "=", "BYTES_BIG_ENDIAN", "?", "gen_altivec_lvsl_reg_di", ":", "gen_altivec_lvsr_reg_di", ";", "gen_pcvr2", "=", "BYTES_BIG_ENDIAN", "?", "gen_altivec_lvsr_reg_di", ":", "gen_altivec_lvsl_reg_di", ";", "}", "else", "{", "shift_mode", "=", "SImode", ";", "gen_ashl", "=", "gen_ashlsi3", ";", "gen_pcvr1", "=", "BYTES_BIG_ENDIAN", "?", "gen_altivec_lvsl_reg_si", ":", "gen_altivec_lvsr_reg_si", ";", "gen_pcvr2", "=", "BYTES_BIG_ENDIAN", "?", "gen_altivec_lvsr_reg_si", ":", "gen_altivec_lvsl_reg_si", ";", "}", "rtx", "tmp", "=", "gen_reg_rtx", "(", "shift_mode", ")", ";", "idx", "=", "convert_modes", "(", "shift_mode", ",", "idx_mode", ",", "idx", ",", "1", ")", ";", "emit_insn", "(", "gen_ashl", "(", "tmp", ",", "idx", ",", "GEN_INT", "(", "shift", ")", ")", ")", ";", "rtx", "pcvr1", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_pcvr1", "(", "pcvr1", ",", "tmp", ")", ")", ";", "rtx", "sub_target", "=", "simplify_gen_subreg", "(", "V16QImode", ",", "target", ",", "mode", ",", "0", ")", ";", "rtx", "perm1", "=", "gen_altivec_vperm_v8hiv16qi", "(", "sub_target", ",", "sub_target", ",", "sub_target", ",", "pcvr1", ")", ";", "emit_insn", "(", "perm1", ")", ";", "rs6000_expand_vector_set", "(", "target", ",", "val", ",", "const0_rtx", ")", ";", "rtx", "pcvr2", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_pcvr2", "(", "pcvr2", ",", "tmp", ")", ")", ";", "rtx", "perm2", "=", "gen_altivec_vperm_v8hiv16qi", "(", "sub_target", ",", "sub_target", ",", "sub_target", ",", "pcvr2", ")", ";", "emit_insn", "(", "perm2", ")", ";", "}", "</s>" ]

[ "Insert", "VAL", "into", "IDX", "of", "TARGET", ",", "VAL", "size", "is", "same", "of", "the", "vector", "element", ",", "IDX", "is", "variable", "and", "also", "counts", "by", "vector", "element", "size", "for", "p9", "and", "above", "." ]

[ "rs6000", "1", "8", "1", "0" ]

[]

[ "<s>", "bool", "ix86_notrack_prefixed_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "(", "(", "flag_cf_protection", "&", "CF_BRANCH", ")", ")", ")", "return", "false", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "call", "=", "get_call_rtx_from", "(", "insn", ")", ";", "gcc_assert", "(", "call", "!=", "NULL_RTX", ")", ";", "rtx", "addr", "=", "XEXP", "(", "call", ",", "0", ")", ";", "if", "(", "MEM_P", "(", "addr", ")", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "return", "false", ";", "else", "return", "find_reg_note", "(", "insn", ",", "REG_CALL_NOCF_CHECK", ",", "0", ")", ";", "}", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "!", "flag_cet_switch", ")", "{", "rtx", "target", "=", "JUMP_LABEL", "(", "insn", ")", ";", "if", "(", "target", "==", "NULL_RTX", "||", "ANY_RETURN_P", "(", "target", ")", ")", "return", "false", ";", "rtx_insn", "*", "label", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "target", ")", ";", "rtx_insn", "*", "table", "=", "next_insn", "(", "label", ")", ";", "if", "(", "table", "==", "NULL_RTX", "||", "!", "JUMP_TABLE_DATA_P", "(", "table", ")", ")", "return", "false", ";", "else", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "1", "if", "control", "tansfer", "instruction", "INSN", "should", "be", "encoded", "with", "notrack", "prefix", "." ]

[ "i386", "0", "0", "0" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstructionImpl", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ",", "unsigned", "OpIdx0", ",", "unsigned", "OpIdx1", ")", "const", "{", "int", "CommutedOpcode", "=", "commuteOpcode", "(", "*", "MI", ")", ";", "if", "(", "CommutedOpcode", "==", "-", "1", ")", "return", "nullptr", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "MachineOperand", "&", "Src0", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "!", "Src0", ".", "isReg", "(", ")", ")", "return", "nullptr", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "(", "OpIdx0", "!=", "static_cast", "<", "unsigned", ">", "(", "Src0Idx", ")", "||", "OpIdx1", "!=", "static_cast", "<", "unsigned", ">", "(", "Src1Idx", ")", ")", "&&", "(", "OpIdx0", "!=", "static_cast", "<", "unsigned", ">", "(", "Src1Idx", ")", "||", "OpIdx1", "!=", "static_cast", "<", "unsigned", ">", "(", "Src0Idx", ")", ")", ")", "return", "nullptr", ";", "MachineOperand", "&", "Src1", "=", "MI", "->", "getOperand", "(", "Src1Idx", ")", ";", "if", "(", "isVOP2", "(", "*", "MI", ")", ")", "{", "const", "MCInstrDesc", "&", "InstrDesc", "=", "MI", "->", "getDesc", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "!", "isLegalRegOperand", "(", "MRI", ",", "InstrDesc", ".", "OpInfo", "[", "Src1Idx", "]", ",", "Src0", ")", ")", "return", "nullptr", ";", "}", "if", "(", "!", "Src1", ".", "isReg", "(", ")", ")", "{", "if", "(", "NewMI", "||", "!", "Src1", ".", "isImm", "(", ")", "||", "(", "!", "isVOP2", "(", "*", "MI", ")", "&&", "!", "isVOP3", "(", "*", "MI", ")", ")", ")", "{", "return", "nullptr", ";", "}", "if", "(", "MachineOperand", "*", "Src0Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", ")", "{", "MachineOperand", "*", "Src1Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ";", "int", "Src0ModsVal", "=", "Src0Mods", "->", "getImm", "(", ")", ";", "if", "(", "!", "Src1Mods", "&&", "Src0ModsVal", "!=", "0", ")", "return", "nullptr", ";", "int", "Src1ModsVal", "=", "Src1Mods", "->", "getImm", "(", ")", ";", "assert", "(", "(", "Src1ModsVal", "==", "0", ")", "&&", "\"Not expecting modifiers with immediates\"", ")", ";", "Src1Mods", "->", "setImm", "(", "Src0ModsVal", ")", ";", "Src0Mods", "->", "setImm", "(", "Src1ModsVal", ")", ";", "}", "unsigned", "Reg", "=", "Src0", ".", "getReg", "(", ")", ";", "unsigned", "SubReg", "=", "Src0", ".", "getSubReg", "(", ")", ";", "if", "(", "Src1", ".", "isImm", "(", ")", ")", "Src0", ".", "ChangeToImmediate", "(", "Src1", ".", "getImm", "(", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Should only have immediates\"", ")", ";", "Src1", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "Src1", ".", "setSubReg", "(", "SubReg", ")", ";", "}", "else", "{", "MI", "=", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "MI", ",", "NewMI", ",", "OpIdx0", ",", "OpIdx1", ")", ";", "}", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "CommutedOpcode", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "Commutes", "the", "operands", "in", "the", "given", "instruction", "by", "changing", "the", "operands", "order", "and/or", "changing", "the", "instruction", "'s", "opcode", "and/or", "the", "immediate", "value", "operand", "." ]

[ "AMDGPU", "SI", "1", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "0", "0", "\"Not expecting modifiers with immediates\"", "\"Should only have immediates\"" ]

[]

[ "<s>", "bool", "M68kFrameLowering", "::", "canSimplifyCallFramePseudos", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "hasReservedCallFrame", "(", "MF", ")", "||", "(", "hasFP", "(", "MF", ")", "&&", "!", "TRI", "->", "hasStackRealignment", "(", "MF", ")", ")", "||", "TRI", "->", "hasBasePointer", "(", "MF", ")", ";", "}", "</s>" ]

[ "canSimplifyCallFramePseudos", "-", "If", "there", "is", "a", "reserved", "call", "frame", ",", "the", "call", "frame", "pseudos", "can", "be", "simplified", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "static", "bool", "tilegx_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "V8QImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V2SImode", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTOR_MODE_SUPPORTED_P", "." ]

[ "tilegx" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPCISD", "::", "LBRX", ":", "{", "if", "(", "cast", "<", "VTSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", "->", "getVT", "(", ")", "==", "MVT", "::", "i16", ")", "KnownZero", "=", "0xFFFF0000", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpbfp_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpeqfp_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpequb_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpequh_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpequw_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpequd_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgefp_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtfp_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsb_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsh_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsw_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsd_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtub_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtuh_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtuw_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtud_p", ":", "KnownZero", "=", "~", "1U", ";", "break", ";", "}", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "PowerPC", "PPC", "0", "PPCISD::LBRX", "2", "MVT::i16", "0xFFFF0000", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::ppc_altivec_vcmpbfp_p", "Intrinsic::ppc_altivec_vcmpeqfp_p", "Intrinsic::ppc_altivec_vcmpequb_p", "Intrinsic::ppc_altivec_vcmpequh_p", "Intrinsic::ppc_altivec_vcmpequw_p", "Intrinsic::ppc_altivec_vcmpequd_p", "Intrinsic::ppc_altivec_vcmpgefp_p", "Intrinsic::ppc_altivec_vcmpgtfp_p", "Intrinsic::ppc_altivec_vcmpgtsb_p", "Intrinsic::ppc_altivec_vcmpgtsh_p", "Intrinsic::ppc_altivec_vcmpgtsw_p", "Intrinsic::ppc_altivec_vcmpgtsd_p", "Intrinsic::ppc_altivec_vcmpgtub_p", "Intrinsic::ppc_altivec_vcmpgtuh_p", "Intrinsic::ppc_altivec_vcmpgtuw_p", "Intrinsic::ppc_altivec_vcmpgtud_p", "1U" ]

[]

[ "<s>", "bool", "AArch64AsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "unsigned", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "FK_NONE", ")", "return", "true", ";", "if", "(", "Kind", "==", "AArch64", "::", "fixup_aarch64_pcrel_adrp_imm21", ")", "return", "true", ";", "AArch64MCExpr", "::", "VariantKind", "RefKind", "=", "static_cast", "<", "AArch64MCExpr", "::", "VariantKind", ">", "(", "Target", ".", "getRefKind", "(", ")", ")", ";", "AArch64MCExpr", "::", "VariantKind", "SymLoc", "=", "AArch64MCExpr", "::", "getSymbolLoc", "(", "RefKind", ")", ";", "if", "(", "Kind", "==", "AArch64", "::", "fixup_aarch64_ldr_pcrel_imm19", "&&", "SymLoc", "==", "AArch64MCExpr", "::", "VK_GOT", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "AArch64", "AArch64", "AArch64::fixup_aarch64_pcrel_adrp_imm21", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::fixup_aarch64_ldr_pcrel_imm19", "AArch64" ]

[]

[ "<s>", "auto", "end", "(", ")", "const", "{", "return", "Data", ".", "end", "(", ")", ";", "}", "</s>" ]

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "TVM" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldClusterMemOps", "(", "MachineInstr", "&", "FirstLdSt", ",", "MachineInstr", "&", "SecondLdSt", ",", "unsigned", "NumLoads", ")", "const", "{", "const", "MachineOperand", "*", "FirstDst", "=", "nullptr", ";", "const", "MachineOperand", "*", "SecondDst", "=", "nullptr", ";", "if", "(", "(", "isMUBUF", "(", "FirstLdSt", ")", "&&", "isMUBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isMTBUF", "(", "FirstLdSt", ")", "&&", "isMTBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isFLAT", "(", "FirstLdSt", ")", "&&", "isFLAT", "(", "SecondLdSt", ")", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "}", "else", "if", "(", "isSMRD", "(", "FirstLdSt", ")", "&&", "isSMRD", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "}", "else", "if", "(", "isDS", "(", "FirstLdSt", ")", "&&", "isDS", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "if", "(", "!", "FirstDst", "||", "!", "SecondDst", ")", "return", "false", ";", "unsigned", "LoadClusterThreshold", "=", "16", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "FirstDst", "->", "getReg", "(", ")", ")", ";", "return", "(", "NumLoads", "*", "DstRC", "->", "getSize", "(", ")", ")", "<=", "LoadClusterThreshold", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AMDGPU", "SI", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "16" ]

[]

[ "<s>", "virtual", "const", "Z80InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_get_compress_on_flags", "(", "tree", "attributes", ")", "{", "unsigned", "int", "flags", "=", "0", ";", "if", "(", "lookup_attribute", "(", "\"mips16\"", ",", "attributes", ")", "!=", "NULL", ")", "flags", "|=", "MASK_MIPS16", ";", "if", "(", "lookup_attribute", "(", "\"micromips\"", ",", "attributes", ")", "!=", "NULL", ")", "flags", "|=", "MASK_MICROMIPS", ";", "return", "flags", ";", "}", "</s>" ]

[ "Return", "the", "set", "of", "compression", "modes", "that", "are", "explicitly", "required", "by", "the", "attributes", "in", "ATTRIBUTES", "." ]

[ "mips", "0", "\"mips16\"", "\"micromips\"" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "auto", "&", "TM", "=", "TPC", "->", "getTM", "<", "PPCTargetMachine", ">", "(", ")", ";", "ST", "=", "TM", ".", "getSubtargetImpl", "(", "F", ")", ";", "PHINodeSet", "PromotablePHINodes", "=", "getPromotablePHINodes", "(", "F", ")", ";", "B2IMap", "Bool2IntMap", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "auto", "*", "R", "=", "dyn_cast", "<", "ReturnInst", ">", "(", "&", "I", ")", ")", "if", "(", "F", ".", "getReturnType", "(", ")", "->", "isIntegerTy", "(", "1", ")", ")", "Changed", "|=", "runOnUse", "(", "R", "->", "getOperandUse", "(", "0", ")", ",", "PromotablePHINodes", ",", "Bool2IntMap", ")", ";", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "&", "I", ")", ")", "for", "(", "auto", "&", "U", ":", "CI", "->", "operands", "(", ")", ")", "if", "(", "U", "->", "getType", "(", ")", "->", "isIntegerTy", "(", "1", ")", ")", "Changed", "|=", "runOnUse", "(", "U", ",", "PromotablePHINodes", ",", "Bool2IntMap", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "PowerPC", "PPC", "1", "0", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "M680x0Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "M680x0Subtarget", ">", "(", ")", ";", "M680x0MachineFunctionInfo", "*", "MxFI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MxFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "==", "0", ")", "return", "false", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "const", "M680x0InstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "M680x0", "::", "LEA32q", ")", ",", "GlobalBaseReg", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "M680x0II", "::", "MO_GOTPCREL", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "0", "M680x0", "M680x0::LEA32q", "\"_GLOBAL_OFFSET_TABLE_\"", "M680x0II::MO_GOTPCREL" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "ARCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "MCDisassembler", "::", "DecodeStatus", "Result", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "Fail", ";", "}", "uint8_t", "DecodeByte", "=", "(", "Bytes", "[", "1", "]", "&", "0xF7", ")", ">>", "3", ";", "if", "(", "DecodeByte", "<", "0x08", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "Fail", ";", "}", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "uint64_t", "Insn64", ";", "if", "(", "!", "readInstruction64", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn64", ")", ")", "return", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable64", ",", "Instr", ",", "Insn64", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Success", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Successfully decoded 64-bit instruction.\"", ")", ";", "return", "MCDisassembler", "::", "Success", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Not a 64-bit instruction, falling back to 32-bit.\"", ")", ";", "}", "uint32_t", "Insn32", ";", "if", "(", "!", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn32", ")", ")", "{", "return", "Fail", ";", "}", "return", "decodeInstruction", "(", "DecoderTable32", ",", "Instr", ",", "Insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "uint32_t", "Insn16", ";", "if", "(", "!", "readInstruction16", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn16", ")", ")", "{", "return", "Fail", ";", "}", "return", "decodeInstruction", "(", "DecoderTable16", ",", "Instr", ",", "Insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "ARC", "ARC", "2", "0", "1", "0xF7", "3", "0x08", "4", "0", "8", "\"Successfully decoded 64-bit instruction.\"", "\"Not a 64-bit instruction, falling back to 32-bit.\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARMBaseRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "ARM", "::", "GPRRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "ARM", "ARM", "ARM::GPRRegClass" ]

[]

[ "<s>", "bool", "DeadCodeElimination", "::", "erase", "(", "const", "SetVector", "<", "NodeId", ">", "&", "Nodes", ")", "{", "if", "(", "Nodes", ".", "empty", "(", ")", ")", "return", "false", ";", "NodeList", "DRNs", ",", "DINs", ";", "for", "(", "auto", "I", ":", "Nodes", ")", "{", "auto", "BA", "=", "DFG", ".", "addr", "<", "NodeBase", "*", ">", "(", "I", ")", ";", "uint16_t", "Type", "=", "BA", ".", "Addr", "->", "getType", "(", ")", ";", "if", "(", "Type", "==", "NodeAttrs", "::", "Ref", ")", "{", "DRNs", ".", "push_back", "(", "DFG", ".", "addr", "<", "RefNode", "*", ">", "(", "I", ")", ")", ";", "continue", ";", "}", "uint16_t", "Kind", "=", "BA", ".", "Addr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "NodeAttrs", "::", "Stmt", "||", "Kind", "==", "NodeAttrs", "::", "Phi", ")", "{", "for", "(", "auto", "N", ":", "NodeAddr", "<", "CodeNode", "*", ">", "(", "BA", ")", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "DRNs", ".", "push_back", "(", "N", ")", ";", "DINs", ".", "push_back", "(", "DFG", ".", "addr", "<", "InstrNode", "*", ">", "(", "I", ")", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unexpected code node\"", ")", ";", "return", "false", ";", "}", "}", "auto", "UsesFirst", "=", "[", "]", "(", "NodeAddr", "<", "RefNode", "*", ">", "A", ",", "NodeAddr", "<", "RefNode", "*", ">", "B", ")", "->", "bool", "{", "uint16_t", "KindA", "=", "A", ".", "Addr", "->", "getKind", "(", ")", ",", "KindB", "=", "B", ".", "Addr", "->", "getKind", "(", ")", ";", "if", "(", "KindA", "==", "NodeAttrs", "::", "Use", "&&", "KindB", "==", "NodeAttrs", "::", "Def", ")", "return", "true", ";", "if", "(", "KindA", "==", "NodeAttrs", "::", "Def", "&&", "KindB", "==", "NodeAttrs", "::", "Use", ")", "return", "false", ";", "return", "A", ".", "Id", "<", "B", ".", "Id", ";", "}", ";", "llvm", "::", "sort", "(", "DRNs", ".", "begin", "(", ")", ",", "DRNs", ".", "end", "(", ")", ",", "UsesFirst", ")", ";", "if", "(", "trace", "(", ")", ")", "dbgs", "(", ")", "<<", "\"Removing dead ref nodes:\\n\"", ";", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "DRNs", ")", "{", "if", "(", "trace", "(", ")", ")", "dbgs", "(", ")", "<<", "\" \"", "<<", "PrintNode", "<", "RefNode", "*", ">", "(", "RA", ",", "DFG", ")", "<<", "'\\n'", ";", "if", "(", "DFG", ".", "IsUse", "(", "RA", ")", ")", "DFG", ".", "unlinkUse", "(", "RA", ",", "true", ")", ";", "else", "if", "(", "DFG", ".", "IsDef", "(", "RA", ")", ")", "DFG", ".", "unlinkDef", "(", "RA", ",", "true", ")", ";", "}", "for", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ":", "DINs", ")", "{", "NodeAddr", "<", "BlockNode", "*", ">", "BA", "=", "IA", ".", "Addr", "->", "getOwner", "(", "DFG", ")", ";", "BA", ".", "Addr", "->", "removeMember", "(", "IA", ",", "DFG", ")", ";", "if", "(", "!", "DFG", ".", "IsCode", "<", "NodeAttrs", "::", "Stmt", ">", "(", "IA", ")", ")", "continue", ";", "MachineInstr", "*", "MI", "=", "NodeAddr", "<", "StmtNode", "*", ">", "(", "IA", ")", ".", "Addr", "->", "getCode", "(", ")", ";", "if", "(", "trace", "(", ")", ")", "dbgs", "(", ")", "<<", "\"erasing: \"", "<<", "*", "MI", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "erase", "-", "Erases", "an", "element", "identified", "by", "Key", ",", "if", "it", "exists", "." ]

[ "Hexagon", "\"Unexpected code node\"", "\"Removing dead ref nodes:\\n\"", "\" \"", "\"erasing: \"" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "DW", "=", "getAnalysisIfAvailable", "<", "DwarfWriter", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "O", "<<", "\"\\t.syntax unified\\n\"", ";", "if", "(", "Subtarget", "->", "isTargetELF", "(", ")", ")", "{", "std", "::", "string", "CPUString", "=", "Subtarget", "->", "getCPUString", "(", ")", ";", "if", "(", "CPUString", "!=", "\"generic\"", ")", "O", "<<", "\"\\t.cpu \"", "<<", "CPUString", "<<", "'\\n'", ";", "if", "(", "Subtarget", "->", "hasVFP2", "(", ")", ")", "O", "<<", "\"\\t.eabi_attribute \"", "<<", "ARMBuildAttrs", "::", "VFP_arch", "<<", "\", 2\\n\"", ";", "if", "(", "!", "UnsafeFPMath", ")", "O", "<<", "\"\\t.eabi_attribute \"", "<<", "ARMBuildAttrs", "::", "ABI_FP_denormal", "<<", "\", 1\\n\"", "<<", "\"\\t.eabi_attribute \"", "<<", "ARMBuildAttrs", "::", "ABI_FP_exceptions", "<<", "\", 1\\n\"", ";", "if", "(", "FiniteOnlyFPMath", "(", ")", ")", "O", "<<", "\"\\t.eabi_attribute \"", "<<", "ARMBuildAttrs", "::", "ABI_FP_number_model", "<<", "\", 1\\n\"", ";", "else", "O", "<<", "\"\\t.eabi_attribute \"", "<<", "ARMBuildAttrs", "::", "ABI_FP_number_model", "<<", "\", 3\\n\"", ";", "O", "<<", "\"\\t.eabi_attribute \"", "<<", "ARMBuildAttrs", "::", "ABI_align8_needed", "<<", "\", 1\\n\"", "<<", "\"\\t.eabi_attribute \"", "<<", "ARMBuildAttrs", "::", "ABI_align8_preserved", "<<", "\", 1\\n\"", ";", "if", "(", "Subtarget", "->", "isAAPCS_ABI", "(", ")", "&&", "FloatABIType", "==", "FloatABI", "::", "Hard", ")", "O", "<<", "\"\\t.eabi_attribute \"", "<<", "ARMBuildAttrs", "::", "ABI_HardFP_use", "<<", "\", 3\\n\"", "<<", "\"\\t.eabi_attribute \"", "<<", "ARMBuildAttrs", "::", "ABI_VFP_args", "<<", "\", 1\\n\"", ";", "}", "return", "Result", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "ARM", "ARM", "\"\\t.syntax unified\\n\"", "\"generic\"", "\"\\t.cpu \"", "\"\\t.eabi_attribute \"", "ARMBuildAttrs::VFP_arch", "\", 2\\n\"", "\"\\t.eabi_attribute \"", "ARMBuildAttrs::ABI_FP_denormal", "\", 1\\n\"", "\"\\t.eabi_attribute \"", "ARMBuildAttrs::ABI_FP_exceptions", "\", 1\\n\"", "\"\\t.eabi_attribute \"", "ARMBuildAttrs::ABI_FP_number_model", "\", 1\\n\"", "\"\\t.eabi_attribute \"", "ARMBuildAttrs::ABI_FP_number_model", "\", 3\\n\"", "\"\\t.eabi_attribute \"", "ARMBuildAttrs::ABI_align8_needed", "\", 1\\n\"", "\"\\t.eabi_attribute \"", "ARMBuildAttrs::ABI_align8_preserved", "\", 1\\n\"", "\"\\t.eabi_attribute \"", "ARMBuildAttrs::ABI_HardFP_use", "\", 3\\n\"", "\"\\t.eabi_attribute \"", "ARMBuildAttrs::ABI_VFP_args", "\", 1\\n\"" ]

[]

[ "<s>", "static", "bool", "isExtended", "(", "uint64_t", "TSFlags", ")", "{", "return", "(", "TSFlags", ">>", "HexagonII", "::", "ExtendedPos", ")", "&", "HexagonII", "::", "ExtendedMask", ";", "}", "</s>" ]

[ "Test", "if", "the", "given", "EVT", "is", "extended", "(", "as", "opposed", "to", "being", "simple", ")", "." ]

[ "Hexagon", "HexagonII::ExtendedPos", "HexagonII::ExtendedMask" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "0", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "getSUBriOpcode", "(", "Is64Bit", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "{", "unsigned", "Opc", "=", "getADDriOpcode", "(", "Is64Bit", ",", "Amount", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "unsigned", "Opc", "=", "getSUBriOpcode", "(", "Is64Bit", ",", "CalleeAmt", ")", ";", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "X86", "X86", "0", "0", "1", "0", "1", "3", "1", "3" ]

[]

[ "<s>", "int", "reg_unused_after", "(", "rtx", "reg", ",", "rtx", "insn", ")", "{", "enum", "rtx_code", "code", ";", "rtx", "set", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "!=", "MEM", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "return", "1", ";", "while", "(", "(", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", ")", "{", "rtx", "set", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "code", "=", "GET_CODE", "(", "insn", ")", ";", "if", "(", "code", "==", "CODE_LABEL", ")", "return", "1", ";", "if", "(", "code", "==", "JUMP_INSN", ")", "return", "0", ";", "else", "if", "(", "code", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "{", "int", "i", ";", "int", "retval", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "this_insn", "=", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "i", ")", ";", "rtx", "set", "=", "single_set", "(", "this_insn", ")", ";", "if", "(", "GET_CODE", "(", "this_insn", ")", "==", "CALL_INSN", ")", "code", "=", "CALL_INSN", ";", "else", "if", "(", "GET_CODE", "(", "this_insn", ")", "==", "JUMP_INSN", ")", "{", "if", "(", "INSN_ANNULLED_BRANCH_P", "(", "this_insn", ")", ")", "return", "0", ";", "code", "=", "JUMP_INSN", ";", "}", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_SRC", "(", "set", ")", ")", ")", "return", "0", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "{", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "!=", "MEM", ")", "retval", "=", "1", ";", "else", "return", "0", ";", "}", "if", "(", "set", "==", "0", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "PATTERN", "(", "this_insn", ")", ")", ")", "return", "0", ";", "}", "if", "(", "retval", "==", "1", ")", "return", "1", ";", "else", "if", "(", "code", "==", "JUMP_INSN", ")", "return", "0", ";", "}", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_SRC", "(", "set", ")", ")", ")", "return", "0", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "return", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "!=", "MEM", ";", "if", "(", "set", "==", "0", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", ")", "return", "0", ";", "if", "(", "code", "==", "CALL_INSN", "&&", "call_really_used_regs", "[", "REGNO", "(", "reg", ")", "]", ")", "return", "1", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "REG", "is", "not", "used", "after", "INSN", ".", "We", "assume", "REG", "is", "a", "reload", "reg", ",", "and", "therefore", "does", "not", "live", "past", "labels", "or", "calls", "or", "jumps", "." ]

[ "sh", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "1", "1", "0", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "const", "BlackfinRegisterInfo", "*", "getRegisterInfo", "(", ")", "{", "return", "static_cast", "<", "const", "BlackfinTargetMachine", "&", ">", "(", "TM", ")", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "Blackfin" ]

[]

[ "<s>", "static", "tree", "arm_handle_cmse_nonsecure_call", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "decl", "=", "NULL_TREE", ";", "tree", "fntype", ",", "type", ";", "if", "(", "!", "use_cmse", ")", "{", "*", "no_add_attrs", "=", "true", ";", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute ignored without %<-mcmse%> \"", "\"option\"", ",", "name", ")", ";", "return", "NULL_TREE", ";", "}", "if", "(", "DECL_P", "(", "*", "node", ")", ")", "{", "fntype", "=", "TREE_TYPE", "(", "*", "node", ")", ";", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "VAR_DECL", "||", "TREE_CODE", "(", "*", "node", ")", "==", "TYPE_DECL", ")", "decl", "=", "*", "node", ";", "}", "else", "fntype", "=", "*", "node", ";", "while", "(", "fntype", "&&", "TREE_CODE", "(", "fntype", ")", "==", "POINTER_TYPE", ")", "fntype", "=", "TREE_TYPE", "(", "fntype", ")", ";", "if", "(", "(", "DECL_P", "(", "*", "node", ")", "&&", "!", "decl", ")", "||", "TREE_CODE", "(", "fntype", ")", "!=", "FUNCTION_TYPE", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to base type of a \"", "\"function pointer\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "}", "*", "no_add_attrs", "|=", "cmse_func_args_or_return_in_stack", "(", "NULL", ",", "name", ",", "fntype", ")", ";", "if", "(", "*", "no_add_attrs", ")", "return", "NULL_TREE", ";", "if", "(", "decl", ")", "{", "type", "=", "build_distinct_type_copy", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "TREE_TYPE", "(", "decl", ")", "=", "type", ";", "}", "else", "{", "type", "=", "build_distinct_type_copy", "(", "*", "node", ")", ";", "*", "node", "=", "type", ";", "}", "fntype", "=", "type", ";", "while", "(", "TREE_CODE", "(", "fntype", ")", "!=", "FUNCTION_TYPE", ")", "{", "type", "=", "fntype", ";", "fntype", "=", "TREE_TYPE", "(", "fntype", ")", ";", "fntype", "=", "build_distinct_type_copy", "(", "fntype", ")", ";", "TREE_TYPE", "(", "type", ")", "=", "fntype", ";", "}", "tree", "attrs", "=", "tree_cons", "(", "get_identifier", "(", "\"cmse_nonsecure_call\"", ")", ",", "NULL_TREE", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ";", "TYPE_ATTRIBUTES", "(", "fntype", ")", "=", "attrs", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Called", "upon", "detection", "of", "the", "use", "of", "the", "cmse_nonsecure_call", "attribute", ",", "this", "function", "will", "check", "whether", "the", "attribute", "is", "allowed", "here", "and", "will", "add", "the", "attribute", "to", "the", "function", "type", "tree", "or", "otherwise", "issue", "a", "diagnostic", ".", "The", "reason", "we", "check", "this", "at", "declaration", "time", "is", "to", "only", "allow", "the", "use", "of", "the", "attribute", "with", "declarations", "of", "function", "pointers", "and", "not", "function", "declarations", ".", "This", "function", "checks", "NODE", "is", "of", "the", "expected", "type", "and", "issues", "diagnostics", "otherwise", "using", "NAME", ".", "If", "it", "is", "not", "of", "the", "expected", "type", "*", "NO_ADD_ATTRS", "will", "be", "set", "to", "true", "." ]

[ "arm", "\"%qE attribute ignored without %<-mcmse%> \"", "\"option\"", "\"%qE attribute only applies to base type of a \"", "\"function pointer\"", "\"cmse_nonsecure_call\"" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "DebugLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "32", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "32", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "32", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "if", "(", "isTailCall", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "LowerCall_SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "return", "LowerCall_Darwin", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::OutputArg", "32", "32", "ISD::InputArg", "32", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "MipsDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_R", ":", "case", "InlineAsm", "::", "Constraint_ZC", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "Mips", "Mips", "\"Unexpected asm memory constraint\"" ]

[]

[ "<s>", "virtual", "const", "OR1KRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "OR1K", "OR1K" ]

[]

[ "<s>", "bool", "mep_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "regclass", ")", "{", "if", "(", "from", "==", "to", ")", "return", "false", ";", "if", "(", "TARGET_64BIT_CR_REGS", "&&", "(", "regclass", "==", "CR_REGS", "||", "regclass", "==", "LOADABLE_CR_REGS", ")", "&&", "(", "GET_MODE_SIZE", "(", "to", ")", "<", "8", "||", "GET_MODE_SIZE", "(", "from", ")", "<", "8", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "registers", "in", "CLASS", "can", "not", "represent", "the", "change", "from", "modes", "FROM", "to", "TO", "." ]

[ "mep", "8", "8" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "M0", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "unsigned", "StackPtrReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "StackPtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "StackPtrReg", ")", ")", ";", "}", "unsigned", "FrameReg", "=", "MFI", "->", "getFrameOffsetReg", "(", ")", ";", "if", "(", "FrameReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "FrameReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "FrameReg", ")", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::M0", "AMDGPU::SRC_SHARED_BASE", "AMDGPU::SRC_SHARED_LIMIT", "AMDGPU::SRC_PRIVATE_BASE", "AMDGPU::SRC_PRIVATE_LIMIT", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "SI", "SI", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "static", "int", "m32r_is_insn", "(", "rtx", "insn", ")", "{", "return", "(", "INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "CLOBBER", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "real", "instruction", "bearing", "insn", "." ]

[ "m32r" ]

[]

[ "<s>", "static", "int", "rs6000_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "int", "ret", ";", "reg_class_t", "rclass", ";", "if", "(", "TARGET_DEBUG_COST", ")", "dbg_cost_ctrl", "++", ";", "HARD_REG_SET", "to_vsx", ",", "from_vsx", ";", "to_vsx", "=", "reg_class_contents", "[", "to", "]", "&", "reg_class_contents", "[", "VSX_REGS", "]", ";", "from_vsx", "=", "reg_class_contents", "[", "from", "]", "&", "reg_class_contents", "[", "VSX_REGS", "]", ";", "if", "(", "!", "hard_reg_set_empty_p", "(", "to_vsx", ")", "&&", "!", "hard_reg_set_empty_p", "(", "from_vsx", ")", "&&", "(", "TARGET_VSX", "||", "hard_reg_set_intersect_p", "(", "to_vsx", ",", "from_vsx", ")", ")", ")", "{", "int", "reg", "=", "FIRST_FPR_REGNO", ";", "if", "(", "TARGET_VSX", "||", "(", "TEST_HARD_REG_BIT", "(", "to_vsx", ",", "FIRST_ALTIVEC_REGNO", ")", "&&", "TEST_HARD_REG_BIT", "(", "from_vsx", ",", "FIRST_ALTIVEC_REGNO", ")", ")", ")", "reg", "=", "FIRST_ALTIVEC_REGNO", ";", "ret", "=", "2", "*", "hard_regno_nregs", "(", "reg", ",", "mode", ")", ";", "}", "else", "if", "(", "(", "rclass", "=", "from", ",", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", ")", "||", "(", "rclass", "=", "to", ",", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", ")", ")", "{", "if", "(", "rclass", "==", "FLOAT_REGS", "||", "rclass", "==", "ALTIVEC_REGS", "||", "rclass", "==", "VSX_REGS", ")", "{", "if", "(", "TARGET_DIRECT_MOVE", ")", "{", "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER9", "||", "rs6000_tune", "==", "PROCESSOR_POWER10", ")", "ret", "=", "3", "*", "hard_regno_nregs", "(", "FIRST_GPR_REGNO", ",", "mode", ")", ";", "else", "ret", "=", "4", "*", "hard_regno_nregs", "(", "FIRST_GPR_REGNO", ",", "mode", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "ret", "+=", "2", ";", "}", "else", "ret", "=", "(", "rs6000_memory_move_cost", "(", "mode", ",", "rclass", ",", "false", ")", "+", "rs6000_memory_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "false", ")", ")", ";", "}", "else", "if", "(", "rclass", "==", "CR_REGS", ")", "ret", "=", "4", ";", "else", "if", "(", "(", "rs6000_tune", "==", "PROCESSOR_POWER6", "||", "rs6000_tune", "==", "PROCESSOR_POWER7", "||", "rs6000_tune", "==", "PROCESSOR_POWER8", "||", "rs6000_tune", "==", "PROCESSOR_POWER9", ")", "&&", "reg_class_subset_p", "(", "rclass", ",", "SPECIAL_REGS", ")", ")", "ret", "=", "6", "*", "hard_regno_nregs", "(", "FIRST_GPR_REGNO", ",", "mode", ")", ";", "else", "ret", "=", "2", "*", "hard_regno_nregs", "(", "FIRST_GPR_REGNO", ",", "mode", ")", ";", "}", "else", "ret", "=", "(", "rs6000_register_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "to", ")", "+", "rs6000_register_move_cost", "(", "mode", ",", "from", ",", "GENERAL_REGS", ")", ")", ";", "if", "(", "TARGET_DEBUG_COST", ")", "{", "if", "(", "dbg_cost_ctrl", "==", "1", ")", "fprintf", "(", "stderr", ",", "\"rs6000_register_move_cost: ret=%d, mode=%s, from=%s, to=%s\\n\"", ",", "ret", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_class_names", "[", "from", "]", ",", "reg_class_names", "[", "to", "]", ")", ";", "dbg_cost_ctrl", "--", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expression", "returning", "the", "cost", "of", "moving", "data", "from", "a", "register", "of", "class", "CLASS1", "to", "one", "of", "CLASS2", "." ]

[ "rs6000", "2", "3", "4", "2", "4", "6", "2", "1", "\"rs6000_register_move_cost: ret=%d, mode=%s, from=%s, to=%s\\n\"" ]

[]

[ "<s>", "const", "MCExpr", "*", "createExprForCAPIVariantKind", "(", "const", "MCExpr", "*", "SubExpr", ",", "unsigned", "VariantKind", ")", "override", "{", "switch", "(", "VariantKind", ")", "{", "case", "LLVMDisassembler_VariantKind_ARM_HI16", ":", "return", "ARMMCExpr", "::", "createUpper16", "(", "SubExpr", ",", "Ctx", ")", ";", "case", "LLVMDisassembler_VariantKind_ARM_LO16", ":", "return", "ARMMCExpr", "::", "createLower16", "(", "SubExpr", ",", "Ctx", ")", ";", "default", ":", "return", "MCRelocationInfo", "::", "createExprForCAPIVariantKind", "(", "SubExpr", ",", "VariantKind", ")", ";", "}", "}", "</s>" ]

[ "Create", "an", "MCExpr", "for", "the", "target-specific", "VariantKind", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "WebAssemblyOptimizeLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "assert", "(", "MRI", ".", "tracksLiveness", "(", ")", "&&", "\"OptimizeLiveIntervals expects liveness\"", ")", ";", "SmallVector", "<", "LiveInterval", "*", ",", "4", ">", "SplitLIs", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MRI", ".", "reg_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "LIS", ".", "splitSeparateComponents", "(", "LIS", ".", "getInterval", "(", "Reg", ")", ",", "SplitLIs", ")", ";", "if", "(", "Reg", "==", "TRI", ".", "getFrameRegister", "(", "MF", ")", "&&", "SplitLIs", ".", "size", "(", ")", ">", "0", ")", "{", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", "->", "setFrameBaseVreg", "(", "SplitLIs", ".", "back", "(", ")", "->", "reg", "(", ")", ")", ";", "}", "SplitLIs", ".", "clear", "(", ")", ";", "}", "for", "(", "auto", "MII", "=", "MF", ".", "begin", "(", ")", "->", "begin", "(", ")", ",", "MIE", "=", "MF", ".", "begin", "(", ")", "->", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "MII", "++", ";", "if", "(", "MI", "->", "isImplicitDef", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "{", "LiveInterval", "&", "LI", "=", "LIS", ".", "getInterval", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "LIS", ".", "removeVRegDefAt", "(", "LI", ",", "LIS", ".", "getInstructionIndex", "(", "*", "MI", ")", ".", "getRegSlot", "(", ")", ")", ";", "LIS", ".", "RemoveMachineInstrFromMaps", "(", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "WebAssembly", "WebAssembly", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "\"OptimizeLiveIntervals expects liveness\"", "4", "0", "WebAssembly", "0", "WebAssembly", "0", "0" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "IsO32", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeReturn", "(", "Outs", ",", "getTargetMachine", "(", ")", ".", "Options", ".", "UseSoftFloat", ",", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "unsigned", "V0", "=", "IsN64", "?", "Mips", "::", "V0_64", ":", "Mips", "::", "V0", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "V0", ",", "getPointerTy", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips", "Mips", "Mips", "4", "1", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "Mips", "Mips", "Mips", "Mips", "\"sret virtual register not created in the entry block\"", "Mips::V0_64", "Mips::V0", "1", "0", "MipsISD::Ret", "MVT::Other", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "can", "safely", "be", "outlined", "from", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "int", "s390_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "case", "scalar_load", ":", "case", "scalar_store", ":", "case", "vector_stmt", ":", "case", "vector_load", ":", "case", "vector_store", ":", "case", "vector_gather_load", ":", "case", "vector_scatter_store", ":", "case", "vec_to_scalar", ":", "case", "scalar_to_vec", ":", "case", "cond_branch_not_taken", ":", "case", "vec_perm", ":", "case", "vec_promote_demote", ":", "case", "unaligned_load", ":", "case", "unaligned_store", ":", "return", "1", ";", "case", "cond_branch_taken", ":", "return", "3", ";", "case", "vec_construct", ":", "return", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", "-", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Implement", "targetm.vectorize.builtin_vectorization_cost", "." ]

[ "s390", "1", "3", "1" ]

[]

[ "<s>", "void", "MBlazeRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "int", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "+", "4", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "MBlaze", "::", "ADJCALLSTACKDOWN", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDI", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "MBlaze", "::", "ADJCALLSTACKUP", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDI", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "MBlaze", "MBlaze", "0", "4", "0", "1", "MBlaze::ADJCALLSTACKDOWN", "MBlaze::ADDI", "MBlaze::R1", "MBlaze::R1", "MBlaze::ADJCALLSTACKUP", "MBlaze::ADDI", "MBlaze::R1", "MBlaze::R1" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "EVT", "VT1", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "isZExtFree", "(", "VT1", ",", "VT2", ")", ")", "{", "return", "true", ";", "}", "if", "(", "Val", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "return", "false", ";", "return", "(", "VT1", ".", "isSimple", "(", ")", "&&", "VT1", ".", "isInteger", "(", ")", "&&", "VT2", ".", "isSimple", "(", ")", "&&", "VT2", ".", "isInteger", "(", ")", "&&", "VT1", ".", "getSizeInBits", "(", ")", "<=", "32", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "AArch64", "AArch64", "ISD::LOAD", "32" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeSavedFrameSize", "=", "0", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", ".", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "TRI", "->", "regsOverlap", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "FPReg", ")", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "int", "SlotIndex", "=", "MFI", ".", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeSavedFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "unsigned", "Size", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "unsigned", "Align", "=", "TRI", "->", "getSpillAlignment", "(", "*", "RC", ")", ";", "SpillSlotOffset", "-=", "std", "::", "abs", "(", "SpillSlotOffset", ")", "%", "Align", ";", "SpillSlotOffset", "-=", "Size", ";", "int", "SlotIndex", "=", "MFI", ".", "CreateFixedSpillStackObject", "(", "Size", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "MFI", ".", "ensureMaxAlignment", "(", "Align", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "X86", "X86", "X86", "X86", "X86", "0", "X86", "0", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isCheapToSpeculateCtlz", "(", ")", "const", "{", "return", "Subtarget", "->", "hasV6T2Ops", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "int", "ix86_memory_move_cost", "(", "enum", "machine_mode", "mode", ",", "enum", "reg_class", "class", ",", "int", "in", ")", "{", "if", "(", "FLOAT_CLASS_P", "(", "class", ")", ")", "{", "int", "index", ";", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "index", "=", "0", ";", "break", ";", "case", "DFmode", ":", "index", "=", "1", ";", "break", ";", "case", "XFmode", ":", "index", "=", "2", ";", "break", ";", "default", ":", "return", "100", ";", "}", "return", "in", "?", "ix86_cost", "->", "fp_load", "[", "index", "]", ":", "ix86_cost", "->", "fp_store", "[", "index", "]", ";", "}", "if", "(", "SSE_CLASS_P", "(", "class", ")", ")", "{", "int", "index", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "4", ":", "index", "=", "0", ";", "break", ";", "case", "8", ":", "index", "=", "1", ";", "break", ";", "case", "16", ":", "index", "=", "2", ";", "break", ";", "default", ":", "return", "100", ";", "}", "return", "in", "?", "ix86_cost", "->", "sse_load", "[", "index", "]", ":", "ix86_cost", "->", "sse_store", "[", "index", "]", ";", "}", "if", "(", "MMX_CLASS_P", "(", "class", ")", ")", "{", "int", "index", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "4", ":", "index", "=", "0", ";", "break", ";", "case", "8", ":", "index", "=", "1", ";", "break", ";", "default", ":", "return", "100", ";", "}", "return", "in", "?", "ix86_cost", "->", "mmx_load", "[", "index", "]", ":", "ix86_cost", "->", "mmx_store", "[", "index", "]", ";", "}", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "if", "(", "in", ")", "return", "(", "Q_CLASS_P", "(", "class", ")", "?", "ix86_cost", "->", "int_load", "[", "0", "]", ":", "ix86_cost", "->", "movzbl_load", ")", ";", "else", "return", "(", "Q_CLASS_P", "(", "class", ")", "?", "ix86_cost", "->", "int_store", "[", "0", "]", ":", "ix86_cost", "->", "int_store", "[", "0", "]", "+", "4", ")", ";", "break", ";", "case", "2", ":", "return", "in", "?", "ix86_cost", "->", "int_load", "[", "1", "]", ":", "ix86_cost", "->", "int_store", "[", "1", "]", ";", "default", ":", "if", "(", "mode", "==", "TFmode", ")", "mode", "=", "XFmode", ";", "return", "(", "(", "in", "?", "ix86_cost", "->", "int_load", "[", "2", "]", ":", "ix86_cost", "->", "int_store", "[", "2", "]", ")", "*", "(", "(", "(", "int", ")", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "data", "of", "mode", "M", "between", "a", "register", "and", "memory", ".", "A", "value", "of", "2", "is", "the", "default", ";", "this", "cost", "is", "relative", "to", "those", "in", "`", "REGISTER_MOVE_COST", "'", ".", "If", "moving", "between", "registers", "and", "memory", "is", "more", "expensive", "than", "between", "two", "registers", ",", "you", "should", "define", "this", "macro", "to", "express", "the", "relative", "cost", ".", "Model", "also", "increased", "moving", "costs", "of", "QImode", "registers", "in", "non", "Q_REGS", "classes", "." ]

[ "i386", "0", "1", "2", "100", "4", "0", "8", "1", "16", "2", "100", "4", "0", "8", "1", "100", "1", "0", "0", "0", "4", "2", "1", "1", "2", "2", "1" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "getInitialCFAOffset", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "TRI", "->", "getSlotSize", "(", ")", ";", "}", "</s>" ]

[ "Return", "initial", "CFA", "offset", "value", "i.e", "." ]

[ "X86", "X86" ]

[]