Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "aarch64_simd_check_vect_par_cnst_half", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "high", ")", "{", "int", "nelts", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", "||", "!", "GET_MODE_NUNITS", "(", "mode", ")", ".", "is_constant", "(", "&", "nelts", ")", ")", "return", "false", ";", "rtx", "ideal", "=", "aarch64_simd_vect_par_cnst_half", "(", "mode", ",", "nelts", ",", "high", ")", ";", "HOST_WIDE_INT", "count_op", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "HOST_WIDE_INT", "count_ideal", "=", "XVECLEN", "(", "ideal", ",", "0", ")", ";", "int", "i", "=", "0", ";", "if", "(", "count_op", "!=", "count_ideal", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count_ideal", ";", "i", "++", ")", "{", "rtx", "elt_op", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "rtx", "elt_ideal", "=", "XVECEXP", "(", "ideal", ",", "0", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "elt_op", ")", "||", "INTVAL", "(", "elt_ideal", ")", "!=", "INTVAL", "(", "elt_op", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "OP", "for", "validity", "as", "a", "PARALLEL", "RTX", "vector", "with", "elements", "numbering", "the", "lanes", "of", "either", "the", "high", "(", "HIGH", "==", "TRUE", ")", "or", "low", "lanes", ",", "from", "the", "perspective", "of", "the", "architecture", ".", "See", "the", "diagram", "above", "aarch64_simd_vect_par_cnst_half", "for", "more", "details", "." ]

[ "aarch64", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "MipsAsmBackend", "::", "isMicroMips", "(", "const", "MCSymbol", "*", "Sym", ")", "const", "{", "if", "(", "const", "auto", "*", "ElfSym", "=", "dyn_cast", "<", "const", "MCSymbolELF", ">", "(", "Sym", ")", ")", "{", "if", "(", "ElfSym", "->", "getOther", "(", ")", "&", "ELF", "::", "STO_MIPS_MICROMIPS", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "a", "given", "symbol", "has", "been", "flagged", "with", "MICROMIPS", "flag", "." ]

[ "Mips", "Mips", "Mips" ]

[]

[ "<s>", "bool", "isTarget64BitLP64", "(", ")", "const", "{", "if", "(", "NaClDontBreakABI", ")", "{", "return", "In64BitMode", "&&", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "GNUX32", ")", ";", "}", "return", "In64BitMode", "&&", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "GNUX32", "&&", "!", "TargetTriple", ".", "isOSNaCl", "(", ")", ")", ";", "}", "</s>" ]

[ "Is", "this", "x86_64", "with", "the", "LP64", "programming", "model", "(", "standard", "AMD64", ",", "no", "x32", ")", "?" ]

[ "X86" ]

[]

[ "<s>", "static", "bool", "alpha_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_TImode", ":", "return", "true", ";", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "return", "true", ";", "case", "E_TFmode", ":", "return", "TARGET_HAS_XFLOATING_LIBS", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "The", "scalar", "modes", "supported", "differs", "from", "the", "default", "check-what-c-supports", "version", "in", "that", "sometimes", "TFmode", "is", "available", "even", "when", "long", "double", "indicates", "only", "DFmode", ".", "On", "unicosmk", ",", "we", "have", "the", "situation", "that", "HImode", "does", "n't", "map", "to", "any", "C", "type", ",", "but", "of", "course", "we", "still", "support", "that", "." ]

[ "alpha" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "X86FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "int", "FIOffset", ";", "unsigned", "BasePtr", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "{", "assert", "(", "(", "!", "needsStackRealignment", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "isFixedObjectIndex", "(", "FrameIndex", ")", ")", "&&", "\"Return instruction can only reference SP relative frame objects\"", ")", ";", "FIOffset", "=", "TFI", "->", "getFrameIndexReferenceSP", "(", "MF", ",", "FrameIndex", ",", "BasePtr", ",", "0", ")", ";", "}", "else", "{", "FIOffset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "BasePtr", ")", ";", "}", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LOCAL_ESCAPE", ")", "{", "MachineOperand", "&", "FI", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "FI", ".", "ChangeToImmediate", "(", "FIOffset", ")", ";", "return", ";", "}", "unsigned", "MachineBasePtr", "=", "BasePtr", ";", "if", "(", "Opc", "==", "X86", "::", "LEA64_32r", "&&", "X86", "::", "GR32RegClass", ".", "contains", "(", "BasePtr", ")", ")", "MachineBasePtr", "=", "getX86SubSuperRegister", "(", "BasePtr", ",", "64", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "MachineBasePtr", ",", "false", ")", ";", "if", "(", "BasePtr", "==", "StackPtr", ")", "FIOffset", "+=", "SPAdj", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "STACKMAP", "||", "Opc", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "assert", "(", "BasePtr", "==", "FramePtr", "&&", "\"Expected the FP as base register\"", ")", ";", "int64_t", "Offset", "=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", "+", "FIOffset", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "if", "(", "Offset", "!=", "0", "||", "!", "tryOptimizeLEAtoMOV", "(", "II", ")", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "X86", "X86", "X86", "\"Return instruction can only reference SP relative frame objects\"", "0", "X86::LEA64_32r", "X86::GR32RegClass", "X86", "64", "\"Expected the FP as base register\"", "1", "1", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "0", "3", "3", "3" ]

[]

[ "<s>", "const", "char", "*", "tilegx_asm_output_opcode", "(", "FILE", "*", "stream", ",", "const", "char", "*", "code", ")", "{", "bool", "pseudo", "=", "!", "strcmp", "(", "code", ",", "\"pseudo\"", ")", ";", "if", "(", "!", "tilegx_in_bundle", "&&", "insn_mode", "==", "SImode", ")", "{", "fprintf", "(", "stream", ",", "\"{\\n\\t\"", ")", ";", "tilegx_in_bundle", "=", "true", ";", "}", "if", "(", "tilegx_in_bundle", "&&", "insn_mode", "==", "QImode", ")", "{", "static", "char", "buf", "[", "100", "]", ";", "gcc_assert", "(", "strlen", "(", "code", ")", "+", "3", "+", "1", "<", "sizeof", "(", "buf", ")", ")", ";", "strcpy", "(", "buf", ",", "pseudo", "?", "\"\"", ":", "code", ")", ";", "strcat", "(", "buf", ",", "\"\\n\\t}\"", ")", ";", "tilegx_in_bundle", "=", "false", ";", "return", "buf", ";", "}", "else", "{", "return", "pseudo", "?", "\"\"", ":", "code", ";", "}", "}", "</s>" ]

[ "Implement", "ASM_OUTPUT_OPCODE", ".", "Prepend/append", "curly", "braces", "as", "appropriate", "given", "the", "bundling", "information", "recorded", "by", "tilegx_gen_bundles", "." ]

[ "tilegx", "\"pseudo\"", "\"{\\n\\t\"", "100", "3", "1", "\"\"", "\"\\n\\t}\"", "\"\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"PPC CTR Loops\"", ";", "}", "</s>" ]

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

[ "PowerPC", "\"PPC CTR Loops\"" ]

[]

[ "<s>", "static", "bool", "optimizeCall", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineInstr", "&", "MI", ",", "const", "MachineRegisterInfo", "&", "MRI", ",", "MachineDominatorTree", "&", "MDT", ",", "const", "WebAssemblyTargetLowering", "&", "TLI", ",", "const", "TargetLibraryInfo", "&", "LibInfo", ")", "{", "MachineOperand", "&", "Op1", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "Op1", ".", "isSymbol", "(", ")", ")", "return", "false", ";", "StringRef", "Name", "(", "Op1", ".", "getSymbolName", "(", ")", ")", ";", "bool", "callReturnsInput", "=", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMCPY", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMMOVE", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ";", "if", "(", "!", "callReturnsInput", ")", "return", "false", ";", "LibFunc", "::", "Func", "Func", ";", "if", "(", "!", "LibInfo", ".", "getLibFunc", "(", "Name", ",", "Func", ")", ")", "return", "false", ";", "const", "auto", "&", "Op2", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "switch", "(", "Op2", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Register", ":", "{", "unsigned", "FromReg", "=", "Op2", ".", "getReg", "(", ")", ";", "unsigned", "ToReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FromReg", ")", "!=", "MRI", ".", "getRegClass", "(", "ToReg", ")", ")", "report_fatal_error", "(", "\"Store results: call to builtin function with wrong \"", "\"signature, from/to mismatch\"", ")", ";", "return", "ReplaceDominatedUses", "(", "MBB", ",", "MI", ",", "FromReg", ",", "ToReg", ",", "MRI", ",", "MDT", ")", ";", "}", "case", "MachineOperand", "::", "MO_FrameIndex", ":", "return", "false", ";", "default", ":", "report_fatal_error", "(", "\"Store results: call to builtin function with wrong \"", "\"signature, not consuming reg or frame index\"", ")", ";", "}", "}", "</s>" ]

[ "optimizeCall", "-", "Take", "the", "given", "call", "instruction", "and", "return", "a", "more", "optimal", "value", "to", "replace", "the", "instruction", "with", "or", "0", "if", "a", "more", "optimal", "form", "ca", "n't", "be", "found", "." ]

[ "WebAssembly", "WebAssembly", "1", "2", "0", "\"Store results: call to builtin function with wrong \"", "\"signature, from/to mismatch\"", "\"Store results: call to builtin function with wrong \"", "\"signature, not consuming reg or frame index\"" ]

[]

[ "<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", ",", "Subtarget", "->", "isABI_O32", "(", ")", ",", "Subtarget", "->", "isFP64bit", "(", ")", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeReturn", "(", "Outs", ",", "Subtarget", "->", "mipsSEUsesSoftFloat", "(", ")", ",", "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", "=", "Subtarget", "->", "isABI_N64", "(", ")", "?", "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", ")", ";", "}", "</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" ]

[]

[ "<s>", "virtual", "bool", "enableMachineScheduler", "(", ")", "const", "{", "return", "getGeneration", "(", ")", "<=", "NORTHERN_ISLANDS", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "R600" ]

[]

[ "<s>", "unsigned", "BPFRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "BPF", "::", "R0", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "BPF", "BPF", "BPF::R0" ]

[]

[ "<s>", "struct", "rtx_def", "*", "c4x_function_arg", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ")", "{", "int", "reg", "=", "0", ";", "if", "(", "!", "cum", "->", "init", ")", "{", "cum", "->", "maxfloats", "=", "(", "cum", "->", "floats", ">", "2", ")", "?", "2", ":", "cum", "->", "floats", ";", "cum", "->", "maxints", "=", "(", "cum", "->", "ints", ">", "6", "-", "cum", "->", "maxfloats", ")", "?", "6", "-", "cum", "->", "maxfloats", ":", "cum", "->", "ints", ";", "if", "(", "!", "cum", "->", "prototype", ")", "cum", "->", "maxints", "=", "6", ";", "cum", "->", "ints", "=", "cum", "->", "floats", "=", "0", ";", "cum", "->", "init", "=", "1", ";", "}", "if", "(", "type", "==", "void_type_node", ")", "return", "0", ";", "if", "(", "!", "TARGET_MEMPARM", "&&", "named", "&&", "type", "&&", "!", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "{", "if", "(", "mode", "==", "QFmode", "||", "mode", "==", "HFmode", ")", "{", "if", "(", "cum", "->", "floats", "<", "cum", "->", "maxfloats", ")", "reg", "=", "c4x_fp_reglist", "[", "cum", "->", "floats", "]", ";", "}", "else", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "Pmode", ")", "{", "if", "(", "cum", "->", "ints", "<", "cum", "->", "maxints", ")", "reg", "=", "c4x_int_reglist", "[", "cum", "->", "maxfloats", "]", "[", "cum", "->", "ints", "]", ";", "}", "}", "else", "if", "(", "!", "TARGET_MEMPARM", "&&", "!", "type", ")", "{", "if", "(", "mode", "==", "QFmode", "||", "mode", "==", "HFmode", ")", "reg", "=", "c4x_fp_reglist", "[", "cum", "->", "floats", "]", ";", "else", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "Pmode", ")", "reg", "=", "c4x_int_reglist", "[", "0", "]", "[", "cum", "->", "ints", "]", ";", "}", "if", "(", "TARGET_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "\"c4x_function_arg(mode=%s, named=%d\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "named", ")", ";", "if", "(", "reg", ")", "fprintf", "(", "stderr", ",", "\", reg=%s\"", ",", "reg_names", "[", "reg", "]", ")", ";", "else", "fprintf", "(", "stderr", ",", "\", stack\"", ")", ";", "fprintf", "(", "stderr", ",", "\")\\n\"", ")", ";", "}", "if", "(", "reg", ")", "return", "gen_rtx_REG", "(", "mode", ",", "reg", ")", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", "." ]

[ "c4x", "0", "2", "2", "6", "6", "6", "0", "1", "0", "0", "\"c4x_function_arg(mode=%s, named=%d\"", "\", reg=%s\"", "\", stack\"", "\")\\n\"" ]

[]

[ "<s>", "void", "PPCTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "ST", "->", "getDarwinDirective", "(", ")", "==", "PPC", "::", "DIR_A2", ")", "{", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "}", "BaseT", "::", "getUnrollingPreferences", "(", "L", ",", "UP", ")", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "PowerPC", "PPC", "PPC::DIR_A2" ]

[]

[ "<s>", "static", "int", "bfin_comp_type_attributes", "(", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "e_funkind", "kind1", ",", "kind2", ";", "if", "(", "TREE_CODE", "(", "type1", ")", "!=", "FUNCTION_TYPE", ")", "return", "1", ";", "kind1", "=", "funkind", "(", "type1", ")", ";", "kind2", "=", "funkind", "(", "type2", ")", ";", "if", "(", "kind1", "!=", "kind2", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "\"nesting\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"nesting\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "\"saveall\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"saveall\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "\"kspisusp\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"kspisusp\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "\"longcall\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"longcall\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "0", "if", "the", "attributes", "for", "two", "types", "are", "incompatible", ",", "1", "if", "they", "are", "compatible", ",", "and", "2", "if", "they", "are", "nearly", "compatible", "(", "which", "causes", "a", "warning", "to", "be", "generated", ")", "." ]

[ "bfin", "1", "0", "\"nesting\"", "\"nesting\"", "0", "\"saveall\"", "\"saveall\"", "0", "\"kspisusp\"", "\"kspisusp\"", "0", "\"longcall\"", "\"longcall\"", "0", "1" ]

[]

[ "<s>", "static", "int", "ix86_avx_u128_mode_needed", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "link", ";", "for", "(", "link", "=", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ";", "link", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "link", ",", "0", ")", ")", "==", "USE", ")", "{", "rtx", "arg", "=", "XEXP", "(", "XEXP", "(", "link", ",", "0", ")", ",", "0", ")", ";", "if", "(", "ix86_check_avx_upper_register", "(", "arg", ")", ")", "return", "AVX_U128_DIRTY", ";", "}", "}", "return", "AVX_U128_CLEAN", ";", "}", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "ix86_check_avx_upper_register", "(", "*", "iter", ")", ")", "return", "AVX_U128_DIRTY", ";", "return", "AVX_U128_ANY", ";", "}", "</s>" ]

[ "Return", "needed", "mode", "for", "entity", "in", "optimize_mode_switching", "pass", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_hard_regno_call_part_clobbered", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "FP_REGNUM_P", "(", "regno", ")", "&&", "maybe_gt", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "8", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_CALL_PART_CLOBBERED", ".", "The", "callee", "only", "saves", "the", "lower", "64", "bits", "of", "a", "128-bit", "register", ".", "Tell", "the", "compiler", "the", "callee", "clobbers", "the", "top", "64", "bits", "when", "restoring", "the", "bottom", "64", "bits", "." ]

[ "aarch64", "8" ]

[]

[ "<s>", "void", "ix86_expand_unary_operator", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "bool", "matching_memory", "=", "false", ";", "rtx", "src", ",", "dst", ",", "op", ",", "clob", ";", "dst", "=", "operands", "[", "0", "]", ";", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "MEM_P", "(", "dst", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "dst", ",", "src", ")", ")", "matching_memory", "=", "true", ";", "else", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "}", "if", "(", "MEM_P", "(", "src", ")", "&&", "!", "matching_memory", ")", "src", "=", "force_reg", "(", "mode", ",", "src", ")", ";", "op", "=", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_fmt_e", "(", "code", ",", "mode", ",", "src", ")", ")", ";", "if", "(", "code", "==", "NOT", ")", "emit_insn", "(", "op", ")", ";", "else", "{", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "op", ",", "clob", ")", ")", ")", ";", "}", "if", "(", "dst", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "dst", ")", ";", "}", "</s>" ]

[ "Attempt", "to", "expand", "a", "unary", "operator", ".", "Make", "the", "expansion", "closer", "to", "the", "actual", "machine", ",", "then", "just", "general_operand", ",", "which", "will", "allow", "2", "separate", "memory", "references", "(", "one", "output", ",", "one", "input", ")", "in", "a", "single", "insn", "." ]

[ "i386", "0", "1", "2", "0", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "*", "MIa", ",", "MachineInstr", "*", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "BaseRegA", "=", "0", ",", "BaseRegB", "=", "0", ";", "int", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "int", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "assert", "(", "MIa", "&&", "(", "MIa", "->", "mayLoad", "(", ")", "||", "MIa", "->", "mayStore", "(", ")", ")", "&&", "\"MIa must be a store or a load\"", ")", ";", "assert", "(", "MIb", "&&", "(", "MIb", "->", "mayLoad", "(", ")", "||", "MIb", "->", "mayStore", "(", ")", ")", "&&", "\"MIb must be a store or a load\"", ")", ";", "if", "(", "MIa", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", "->", "hasOrderedMemoryRef", "(", ")", "||", "MIb", "->", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "getLdStBaseRegImmOfsWidth", "(", "MIa", ",", "BaseRegA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getLdStBaseRegImmOfsWidth", "(", "MIb", ",", "BaseRegB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseRegA", "==", "BaseRegB", ")", "{", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "AArch64", "AArch64", "0", "0", "0", "0", "0", "0", "\"MIa must be a store or a load\"", "\"MIb must be a store or a load\"" ]

[]

[ "<s>", "bool", "ix86_check_builtin_isa_match", "(", "unsigned", "int", "fcode", ",", "HOST_WIDE_INT", "*", "pbisa", ",", "HOST_WIDE_INT", "*", "pbisa2", ")", "{", "HOST_WIDE_INT", "isa", "=", "ix86_isa_flags", ";", "HOST_WIDE_INT", "isa2", "=", "ix86_isa_flags2", ";", "HOST_WIDE_INT", "bisa", "=", "ix86_builtins_isa", "[", "fcode", "]", ".", "isa", ";", "HOST_WIDE_INT", "bisa2", "=", "ix86_builtins_isa", "[", "fcode", "]", ".", "isa2", ";", "if", "(", "(", "(", "bisa", "&", "(", "OPTION_MASK_ISA_SSE", "|", "OPTION_MASK_ISA_3DNOW_A", ")", ")", "==", "(", "OPTION_MASK_ISA_SSE", "|", "OPTION_MASK_ISA_3DNOW_A", ")", ")", "&&", "(", "isa", "&", "(", "OPTION_MASK_ISA_SSE", "|", "OPTION_MASK_ISA_3DNOW_A", ")", ")", "!=", "0", ")", "isa", "|=", "(", "OPTION_MASK_ISA_SSE", "|", "OPTION_MASK_ISA_3DNOW_A", ")", ";", "if", "(", "(", "(", "bisa", "&", "(", "OPTION_MASK_ISA_SSE4_2", "|", "OPTION_MASK_ISA_CRC32", ")", ")", "==", "(", "OPTION_MASK_ISA_SSE4_2", "|", "OPTION_MASK_ISA_CRC32", ")", ")", "&&", "(", "isa", "&", "(", "OPTION_MASK_ISA_SSE4_2", "|", "OPTION_MASK_ISA_CRC32", ")", ")", "!=", "0", ")", "isa", "|=", "(", "OPTION_MASK_ISA_SSE4_2", "|", "OPTION_MASK_ISA_CRC32", ")", ";", "if", "(", "(", "(", "bisa", "&", "(", "OPTION_MASK_ISA_FMA", "|", "OPTION_MASK_ISA_FMA4", ")", ")", "==", "(", "OPTION_MASK_ISA_FMA", "|", "OPTION_MASK_ISA_FMA4", ")", ")", "&&", "(", "isa", "&", "(", "OPTION_MASK_ISA_FMA", "|", "OPTION_MASK_ISA_FMA4", ")", ")", "!=", "0", ")", "isa", "|=", "(", "OPTION_MASK_ISA_FMA", "|", "OPTION_MASK_ISA_FMA4", ")", ";", "if", "(", "(", "(", "(", "bisa", "&", "(", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "==", "(", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "||", "(", "bisa2", "&", "OPTION_MASK_ISA2_AVXVNNI", ")", "!=", "0", ")", "&&", "(", "(", "(", "isa", "&", "(", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "==", "(", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "||", "(", "isa2", "&", "OPTION_MASK_ISA2_AVXVNNI", ")", "!=", "0", ")", ")", "{", "isa", "|=", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ";", "isa2", "|=", "OPTION_MASK_ISA2_AVXVNNI", ";", "}", "if", "(", "(", "bisa", "&", "OPTION_MASK_ISA_MMX", ")", "&&", "!", "TARGET_MMX", "&&", "TARGET_MMX_WITH_SSE", "&&", "fcode", "!=", "IX86_BUILTIN_MASKMOVQ", ")", "{", "bisa", "&=", "~", "OPTION_MASK_ISA_MMX", ";", "bisa", "|=", "OPTION_MASK_ISA_SSE2", ";", "}", "if", "(", "pbisa", ")", "*", "pbisa", "=", "bisa", ";", "if", "(", "pbisa2", ")", "*", "pbisa2", "=", "bisa2", ";", "return", "(", "bisa", "&", "isa", ")", "==", "bisa", "&&", "(", "bisa2", "&", "isa2", ")", "==", "bisa2", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "necessary", "isa", "options", "for", "this", "builtin", "exist", ",", "else", "false", ".", "fcode", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";" ]

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

[]

[ "<s>", "static", "void", "rs6000_adjust_vect_cost_per_loop", "(", "rs6000_cost_data", "*", "data", ")", "{", "struct", "loop", "*", "loop", "=", "data", "->", "loop_info", ";", "gcc_assert", "(", "loop", ")", ";", "loop_vec_info", "loop_vinfo", "=", "loop_vec_info_for_loop", "(", "loop", ")", ";", "if", "(", "LOOP_VINFO_FULLY_WITH_LENGTH_P", "(", "loop_vinfo", ")", ")", "{", "rgroup_controls", "*", "rgc", ";", "unsigned", "int", "num_vectors_m1", ";", "unsigned", "int", "shift_cnt", "=", "0", ";", "FOR_EACH_VEC_ELT", "(", "LOOP_VINFO_LENS", "(", "loop_vinfo", ")", ",", "num_vectors_m1", ",", "rgc", ")", "if", "(", "rgc", "->", "type", ")", "shift_cnt", "+=", "num_vectors_m1", "+", "1", ";", "rs6000_add_stmt_cost", "(", "loop_vinfo", ",", "(", "void", "*", ")", "data", ",", "shift_cnt", ",", "scalar_stmt", ",", "NULL", ",", "NULL_TREE", ",", "0", ",", "vect_body", ")", ";", "}", "}", "</s>" ]

[ "For", "some", "target", "specific", "vectorization", "cost", "which", "ca", "n't", "be", "handled", "per", "stmt", ",", "we", "check", "the", "requisite", "conditions", "and", "adjust", "the", "vectorization", "cost", "accordingly", "if", "satisfied", ".", "One", "typical", "example", "is", "to", "model", "shift", "cost", "for", "vector", "with", "length", "by", "counting", "number", "of", "required", "lengths", "under", "condition", "LOOP_VINFO_FULLY_WITH_LENGTH_P", "." ]

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

[]

[ "<s>", "void", "HexagonTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_HEX_GPREL", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_HEX_GPREL", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\".sdata\"", "\".sbss\"" ]

[]

[ "<s>", "static", "bool", "r10k_safe_mem_expr_p", "(", "tree", "expr", ",", "unsigned", "HOST_WIDE_INT", "offset", ")", "{", "HOST_WIDE_INT", "bitoffset", ",", "bitsize", ";", "tree", "inner", ",", "var_offset", ";", "machine_mode", "mode", ";", "int", "unsigned_p", ",", "volatile_p", ";", "inner", "=", "get_inner_reference", "(", "expr", ",", "&", "bitsize", ",", "&", "bitoffset", ",", "&", "var_offset", ",", "&", "mode", ",", "&", "unsigned_p", ",", "&", "volatile_p", ",", "false", ")", ";", "if", "(", "!", "DECL_P", "(", "inner", ")", "||", "!", "DECL_SIZE_UNIT", "(", "inner", ")", "||", "var_offset", ")", "return", "false", ";", "offset", "+=", "bitoffset", "/", "BITS_PER_UNIT", ";", "return", "offset", "<", "tree_to_uhwi", "(", "DECL_SIZE_UNIT", "(", "inner", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "MEM", "with", "MEM_EXPR", "EXPR", "and", "MEM_OFFSET", "OFFSET", "is", "an", "in-range", "access", "to", "an", "automatic", "variable", ",", "or", "to", "an", "object", "with", "a", "link-time-constant", "address", "." ]

[ "mips" ]

[]

[ "<s>", "const", "char", "*", "rs6000_pltseq_template", "(", "rtx", "*", "operands", ",", "int", "which", ")", "{", "const", "char", "*", "rel64", "=", "TARGET_64BIT", "?", "\"64\"", ":", "\"\"", ";", "char", "tls", "[", "30", "]", ";", "tls", "[", "0", "]", "=", "0", ";", "if", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", "==", "UNSPEC", ")", "{", "char", "off", "=", "which", "==", "RS6000_PLTSEQ_PLT_PCREL34", "?", "'8'", ":", "'4'", ";", "if", "(", "XINT", "(", "operands", "[", "3", "]", ",", "1", ")", "==", "UNSPEC_TLSGD", ")", "sprintf", "(", "tls", ",", "\".reloc .-%c,R_PPC%s_TLSGD,%%3\\n\\t\"", ",", "off", ",", "rel64", ")", ";", "else", "if", "(", "XINT", "(", "operands", "[", "3", "]", ",", "1", ")", "==", "UNSPEC_TLSLD", ")", "sprintf", "(", "tls", ",", "\".reloc .-%c,R_PPC%s_TLSLD,%%&\\n\\t\"", ",", "off", ",", "rel64", ")", ";", "}", "gcc_assert", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "||", "DEFAULT_ABI", "==", "ABI_V4", ")", ";", "static", "char", "str", "[", "96", "]", ";", "char", "off", "=", "WORDS_BIG_ENDIAN", "?", "'2'", ":", "'4'", ";", "const", "char", "*", "addend", "=", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_SECURE_PLT", "&&", "flag_pic", "==", "2", "?", "\"+32768\"", ":", "\"\"", ")", ";", "switch", "(", "which", ")", "{", "case", "RS6000_PLTSEQ_TOCSAVE", ":", "sprintf", "(", "str", ",", "\"st%s\\n\\t\"", "\"%s.reloc .-4,R_PPC%s_PLTSEQ,%%z2\"", ",", "TARGET_64BIT", "?", "\"d 2,24(1)\"", ":", "\"w 2,12(1)\"", ",", "tls", ",", "rel64", ")", ";", "break", ";", "case", "RS6000_PLTSEQ_PLT16_HA", ":", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "!", "flag_pic", ")", "sprintf", "(", "str", ",", "\"lis %%0,0\\n\\t\"", "\"%s.reloc .-%c,R_PPC%s_PLT16_HA,%%z2\"", ",", "tls", ",", "off", ",", "rel64", ")", ";", "else", "sprintf", "(", "str", ",", "\"addis %%0,%%1,0\\n\\t\"", "\"%s.reloc .-%c,R_PPC%s_PLT16_HA,%%z2%s\"", ",", "tls", ",", "off", ",", "rel64", ",", "addend", ")", ";", "break", ";", "case", "RS6000_PLTSEQ_PLT16_LO", ":", "sprintf", "(", "str", ",", "\"l%s %%0,0(%%1)\\n\\t\"", "\"%s.reloc .-%c,R_PPC%s_PLT16_LO%s,%%z2%s\"", ",", "TARGET_64BIT", "?", "\"d\"", ":", "\"wz\"", ",", "tls", ",", "off", ",", "rel64", ",", "TARGET_64BIT", "?", "\"_DS\"", ":", "\"\"", ",", "addend", ")", ";", "break", ";", "case", "RS6000_PLTSEQ_MTCTR", ":", "sprintf", "(", "str", ",", "\"mtctr %%1\\n\\t\"", "\"%s.reloc .-4,R_PPC%s_PLTSEQ,%%z2%s\"", ",", "tls", ",", "rel64", ",", "addend", ")", ";", "break", ";", "case", "RS6000_PLTSEQ_PLT_PCREL34", ":", "sprintf", "(", "str", ",", "\"pl%s %%0,0(0),1\\n\\t\"", "\"%s.reloc .-8,R_PPC%s_PLT_PCREL34_NOTOC,%%z2\"", ",", "TARGET_64BIT", "?", "\"d\"", ":", "\"wz\"", ",", "tls", ",", "rel64", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "str", ";", "}", "</s>" ]

[ "Output", "indirect", "call", "insns", ".", "WHICH", "is", "0", "for", "tocsave", ",", "1", "for", "plt16_ha", ",", "2", "for", "plt16_lo", ",", "3", "for", "mtctr", "." ]

[ "rs6000", "\"64\"", "\"\"", "30", "0", "0", "3", "3", "1", "\".reloc .-%c,R_PPC%s_TLSGD,%%3\\n\\t\"", "3", "1", "\".reloc .-%c,R_PPC%s_TLSLD,%%&\\n\\t\"", "96", "2", "\"+32768\"", "\"\"", "\"st%s\\n\\t\"", "\"%s.reloc .-4,R_PPC%s_PLTSEQ,%%z2\"", "\"d 2,24(1)\"", "\"w 2,12(1)\"", "\"lis %%0,0\\n\\t\"", "\"%s.reloc .-%c,R_PPC%s_PLT16_HA,%%z2\"", "\"addis %%0,%%1,0\\n\\t\"", "\"%s.reloc .-%c,R_PPC%s_PLT16_HA,%%z2%s\"", "\"l%s %%0,0(%%1)\\n\\t\"", "\"%s.reloc .-%c,R_PPC%s_PLT16_LO%s,%%z2%s\"", "\"d\"", "\"wz\"", "\"_DS\"", "\"\"", "\"mtctr %%1\\n\\t\"", "\"%s.reloc .-4,R_PPC%s_PLTSEQ,%%z2%s\"", "\"pl%s %%0,0(0),1\\n\\t\"", "\"%s.reloc .-8,R_PPC%s_PLT_PCREL34_NOTOC,%%z2\"", "\"d\"", "\"wz\"" ]

[]

[ "<s>", "bool", "X86LoadValueInjectionLoadHardeningPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" *****\\n\"", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "useLVILoadHardening", "(", ")", ")", "return", "false", ";", "if", "(", "!", "STI", "->", "is64Bit", "(", ")", ")", "report_fatal_error", "(", "\"LVI load hardening is only supported on 64-bit\"", ",", "false", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", ".", "hasOptNone", "(", ")", "&&", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "++", "NumFunctionsConsidered", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Building gadget graph...\\n\"", ")", ";", "const", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "auto", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "std", "::", "unique_ptr", "<", "MachineGadgetGraph", ">", "Graph", "=", "getGadgetGraph", "(", "MF", ",", "MLI", ",", "MDT", ",", "MDF", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Building gadget graph... Done\\n\"", ")", ";", "if", "(", "Graph", "==", "nullptr", ")", "return", "false", ";", "if", "(", "EmitDotVerify", ")", "{", "writeGadgetGraph", "(", "outs", "(", ")", ",", "MF", ",", "Graph", ".", "get", "(", ")", ")", ";", "return", "false", ";", "}", "if", "(", "EmitDot", "||", "EmitDotOnly", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Emitting gadget graph...\\n\"", ")", ";", "std", "::", "error_code", "FileError", ";", "std", "::", "string", "FileName", "=", "\"lvi.\"", ";", "FileName", "+=", "MF", ".", "getName", "(", ")", ";", "FileName", "+=", "\".dot\"", ";", "raw_fd_ostream", "FileOut", "(", "FileName", ",", "FileError", ")", ";", "if", "(", "FileError", ")", "errs", "(", ")", "<<", "FileError", ".", "message", "(", ")", ";", "writeGadgetGraph", "(", "FileOut", ",", "MF", ",", "Graph", ".", "get", "(", ")", ")", ";", "FileOut", ".", "close", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Emitting gadget graph... Done\\n\"", ")", ";", "if", "(", "EmitDotOnly", ")", "return", "false", ";", "}", "int", "FencesInserted", ";", "if", "(", "!", "OptimizePluginPath", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "OptimizeDL", ".", "isValid", "(", ")", ")", "{", "std", "::", "string", "ErrorMsg", ";", "OptimizeDL", "=", "llvm", "::", "sys", "::", "DynamicLibrary", "::", "getPermanentLibrary", "(", "OptimizePluginPath", ".", "c_str", "(", ")", ",", "&", "ErrorMsg", ")", ";", "if", "(", "!", "ErrorMsg", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"Failed to load opt plugin: \\\"\"", "+", "ErrorMsg", "+", "'\\\"'", ")", ";", "OptimizeCut", "=", "(", "OptimizeCutT", ")", "OptimizeDL", ".", "getAddressOfSymbol", "(", "\"optimize_cut\"", ")", ";", "if", "(", "!", "OptimizeCut", ")", "report_fatal_error", "(", "\"Invalid optimization plugin\"", ")", ";", "}", "FencesInserted", "=", "hardenLoadsWithPlugin", "(", "MF", ",", "std", "::", "move", "(", "Graph", ")", ")", ";", "}", "else", "{", "FencesInserted", "=", "hardenLoadsWithHeuristic", "(", "MF", ",", "std", "::", "move", "(", "Graph", ")", ")", ";", "}", "if", "(", "FencesInserted", ">", "0", ")", "++", "NumFunctionsMitigated", ";", "NumFences", "+=", "FencesInserted", ";", "return", "(", "FencesInserted", ">", "0", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"***** \"", "\" : \"", "\" *****\\n\"", "X86", "\"LVI load hardening is only supported on 64-bit\"", "\"Building gadget graph...\\n\"", "\"Building gadget graph... Done\\n\"", "\"Emitting gadget graph...\\n\"", "\"lvi.\"", "\".dot\"", "\"Emitting gadget graph... Done\\n\"", "\"Failed to load opt plugin: \\\"\"", "\"optimize_cut\"", "\"Invalid optimization plugin\"", "0", "0" ]

[]

[ "<s>", "StackOffset", "VEFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "VERegisterInfo", "*", "RegInfo", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "bool", "isFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "int64_t", "FrameOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "FrameReg", "=", "VE", "::", "SX11", ";", "return", "StackOffset", "::", "getFixed", "(", "FrameOffset", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ")", ";", "}", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "isFixed", ")", "{", "if", "(", "hasBP", "(", "MF", ")", ")", "FrameReg", "=", "VE", "::", "SX17", ";", "else", "FrameReg", "=", "VE", "::", "SX11", ";", "return", "StackOffset", "::", "getFixed", "(", "FrameOffset", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ")", ";", "}", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "FrameOffset", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "VE", "VE", "VE", "VE::SX11", "VE::SX17", "VE::SX11" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "unsigned", "Size", "=", "getFixupKindSize", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "int64_t", "SignedValue", "=", "static_cast", "<", "int64_t", ">", "(", "Value", ")", ";", "if", "(", "(", "Target", ".", "isAbsolute", "(", ")", "||", "IsResolved", ")", "&&", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ".", "Flags", "&", "MCFixupKindInfo", "::", "FKF_IsPCRel", ")", "{", "if", "(", "Size", ">", "0", "&&", "!", "isIntN", "(", "Size", "*", "8", ",", "SignedValue", ")", ")", "Asm", ".", "getContext", "(", ")", ".", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "\"value of \"", "+", "Twine", "(", "SignedValue", ")", "+", "\" is too large for field of \"", "+", "Twine", "(", "Size", ")", "+", "(", "(", "Size", "==", "1", ")", "?", "\" byte.\"", ":", "\" bytes.\"", ")", ")", ";", "}", "else", "{", "assert", "(", "(", "Size", "==", "0", "||", "isIntN", "(", "Size", "*", "8", "+", "1", ",", "SignedValue", ")", ")", "&&", "\"Value does not fit in the Fixup field\"", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", ";", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "X86", "\"Invalid fixup offset!\"", "0", "8", "\"value of \"", "\" is too large for field of \"", "1", "\" byte.\"", "\" bytes.\"", "0", "8", "1", "\"Value does not fit in the Fixup field\"", "0", "8" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineBlockFrequencyInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "SlotIndexes", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreservedID", "(", "MachineDominatorsID", ")", ";", "AU", ".", "addPreservedID", "(", "LiveVariablesID", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "WebAssembly" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "int", "NumBytes", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "bool", "isThumb", ",", "const", "TargetInstrInfo", "&", "TII", ",", "const", "ARMRegisterInfo", "&", "MRI", ",", "DebugLoc", "dl", ")", "{", "if", "(", "isThumb", ")", "emitThumbRegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "ARM", "::", "SP", ",", "ARM", "::", "SP", ",", "NumBytes", ",", "TII", ",", "MRI", ",", "dl", ")", ";", "else", "emitARMRegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "ARM", "::", "SP", ",", "ARM", "::", "SP", ",", "NumBytes", ",", "Pred", ",", "PredReg", ",", "TII", ",", "dl", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "ARM", "ARMCC::CondCodes", "ARM", "ARM::SP", "ARM::SP", "ARM", "ARM::SP", "ARM::SP" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTargetOpValueMMPC10", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "1", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTargetOpValuePC10 expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_MICROMIPS_PC10_S1", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValueMMPC10", "-", "Return", "binary", "encoding", "of", "the", "microMIPS", "10-bit", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "1", "\"getBranchTargetOpValuePC10 expects only expressions or immediates\"", "0", "Mips::fixup_MICROMIPS_PC10_S1", "0" ]

[]

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

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

[ "TriCore", "TriCore" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "static", "LoadStoreMethod", "PossibleClasses", "[", "]", "=", "{", "{", "&", "AArch64", "::", "GPR64RegClass", ",", "AArch64", "::", "LSPair64_LDR", ",", "AArch64", "::", "LS64_LDR", "}", ",", "{", "&", "AArch64", "::", "FPR64RegClass", ",", "AArch64", "::", "LSFPPair64_LDR", ",", "AArch64", "::", "LSFP64_LDR", "}", ",", "}", ";", "unsigned", "NumClasses", "=", "llvm", "::", "array_lengthof", "(", "PossibleClasses", ")", ";", "emitFrameMemOps", "(", "false", ",", "MBB", ",", "MBBI", ",", "CSI", ",", "TRI", ",", "PossibleClasses", ",", "NumClasses", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "AArch64", "AArch64", "AArch64::GPR64RegClass", "AArch64::LSPair64_LDR", "AArch64::LS64_LDR", "AArch64::FPR64RegClass", "AArch64::LSFPPair64_LDR", "AArch64::LSFP64_LDR" ]

[]

[ "<s>", "bool", "ia64_expand_vecint_minmax", "(", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "xops", "[", "6", "]", ";", "if", "(", "mode", "==", "V8QImode", "&&", "(", "code", "==", "UMIN", "||", "code", "==", "UMAX", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "V4HImode", "&&", "(", "code", "==", "SMIN", "||", "code", "==", "SMAX", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "V4HImode", "&&", "code", "==", "UMAX", ")", "{", "rtx", "x", ",", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "x", "=", "gen_rtx_US_MINUS", "(", "mode", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "x", ")", ")", ";", "emit_insn", "(", "gen_addv4hi3", "(", "operands", "[", "0", "]", ",", "tmp", ",", "operands", "[", "2", "]", ")", ")", ";", "return", "true", ";", "}", "xops", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "xops", "[", "4", "]", "=", "xops", "[", "1", "]", "=", "operands", "[", "1", "]", ";", "xops", "[", "5", "]", "=", "xops", "[", "2", "]", "=", "operands", "[", "2", "]", ";", "switch", "(", "code", ")", "{", "case", "UMIN", ":", "code", "=", "LTU", ";", "break", ";", "case", "UMAX", ":", "code", "=", "GTU", ";", "break", ";", "case", "SMIN", ":", "code", "=", "LT", ";", "break", ";", "case", "SMAX", ":", "code", "=", "GT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "xops", "[", "3", "]", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "ia64_expand_vecint_cmov", "(", "xops", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "an", "integral", "vector", "min", "or", "max", "operation", ".", "Return", "true", "if", "all", "done", "." ]

[ "ia64", "6", "1", "2", "0", "2", "0", "0", "4", "1", "1", "5", "2", "2", "3", "1", "2" ]

[]

[ "<s>", "static", "const", "char", "*", "reg_name_with_mode", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "int", "mlen", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "regno", "==", "R0_REGNO", "&&", "mlen", "==", "1", ")", "return", "\"r0l\"", ";", "if", "(", "regno", "==", "R0_REGNO", "&&", "(", "mlen", "==", "3", "||", "mlen", "==", "4", ")", ")", "return", "\"r2r0\"", ";", "if", "(", "regno", "==", "R0_REGNO", "&&", "mlen", "==", "6", ")", "return", "\"r2r1r0\"", ";", "if", "(", "regno", "==", "R0_REGNO", "&&", "mlen", "==", "8", ")", "return", "\"r3r1r2r0\"", ";", "if", "(", "regno", "==", "R1_REGNO", "&&", "mlen", "==", "1", ")", "return", "\"r1l\"", ";", "if", "(", "regno", "==", "R1_REGNO", "&&", "(", "mlen", "==", "3", "||", "mlen", "==", "4", ")", ")", "return", "\"r3r1\"", ";", "if", "(", "regno", "==", "A0_REGNO", "&&", "TARGET_A16", "&&", "(", "mlen", "==", "3", "||", "mlen", "==", "4", ")", ")", "return", "\"a1a0\"", ";", "return", "reg_names", "[", "regno", "]", ";", "}", "</s>" ]

[ "Since", "register", "names", "indicate", "the", "mode", "they", "'re", "used", "in", ",", "we", "need", "a", "way", "to", "determine", "which", "name", "to", "refer", "to", "the", "register", "with", ".", "Called", "by", "print_operand", "(", ")", "." ]

[ "m32c", "1", "\"r0l\"", "3", "4", "\"r2r0\"", "6", "\"r2r1r0\"", "8", "\"r3r1r2r0\"", "1", "\"r1l\"", "3", "4", "\"r3r1\"", "3", "4", "\"a1a0\"" ]

[]

[ "<s>", "const", "MipsRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "AArch64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "ST", ".", "getSchedModel", "(", ")", ",", "&", "ST", ",", "TII", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "unsigned", "BaseReg", ";", "int64_t", "Offset", ";", "if", "(", "TII", "->", "getMemOpBaseRegImmOfs", "(", "&", "MI", ",", "BaseReg", ",", "Offset", ",", "TRI", ")", ")", "{", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "&", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "SmallVector", "<", "const", "MachineMemOperand", "*", ",", "1", ">", "Accesses", ";", "if", "(", "MI", ".", "mayStore", "(", ")", "&&", "hasStoreToStackSlot", "(", "MI", ",", "Accesses", ")", "&&", "Accesses", ".", "size", "(", ")", "==", "1", ")", "{", "FrameIndex", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "Accesses", ".", "front", "(", ")", "->", "getPseudoValue", "(", ")", ")", "->", "getFrameIndex", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isStoreToStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

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

[]

[ "<s>", "bool", "SystemZTTIImpl", "::", "isLSRCostLess", "(", "TargetTransformInfo", "::", "LSRCost", "&", "C1", ",", "TargetTransformInfo", "::", "LSRCost", "&", "C2", ")", "{", "return", "std", "::", "tie", "(", "C1", ".", "Insns", ",", "C1", ".", "NumRegs", ",", "C1", ".", "AddRecCost", ",", "C1", ".", "NumIVMuls", ",", "C1", ".", "NumBaseAdds", ",", "C1", ".", "ScaleCost", ",", "C1", ".", "SetupCost", ")", "<", "std", "::", "tie", "(", "C2", ".", "Insns", ",", "C2", ".", "NumRegs", ",", "C2", ".", "AddRecCost", ",", "C2", ".", "NumIVMuls", ",", "C2", ".", "NumBaseAdds", ",", "C2", ".", "ScaleCost", ",", "C2", ".", "SetupCost", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "LSR", "cost", "of", "C1", "is", "lower", "than", "C2", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "void", "aarch64_pop_regs", "(", "unsigned", "regno1", ",", "unsigned", "regno2", ",", "HOST_WIDE_INT", "adjustment", ",", "rtx", "*", "cfi_ops", ")", "{", "machine_mode", "mode", "=", "(", "regno1", "<=", "R30_REGNUM", ")", "?", "E_DImode", ":", "E_DFmode", ";", "rtx", "reg1", "=", "gen_rtx_REG", "(", "mode", ",", "regno1", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg1", ",", "*", "cfi_ops", ")", ";", "if", "(", "regno2", "==", "INVALID_REGNUM", ")", "{", "rtx", "mem", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "adjustment", ")", ";", "mem", "=", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "mem", ")", ";", "emit_move_insn", "(", "reg1", ",", "gen_frame_mem", "(", "mode", ",", "mem", ")", ")", ";", "}", "else", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg2", ",", "*", "cfi_ops", ")", ";", "emit_insn", "(", "aarch64_gen_loadwb_pair", "(", "mode", ",", "stack_pointer_rtx", ",", "reg1", ",", "reg2", ",", "adjustment", ")", ")", ";", "}", "}", "</s>" ]

[ "Pop", "the", "two", "registers", "numbered", "REGNO1", ",", "REGNO2", "from", "the", "stack", ",", "adjusting", "it", "afterwards", "by", "ADJUSTMENT", "and", "writing", "the", "appropriate", "REG_CFA_RESTORE", "notes", "into", "CFI_OPS", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "WebAssemblyInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "CONST_I32", ":", "case", "WebAssembly", "::", "CONST_I64", ":", "case", "WebAssembly", "::", "CONST_F32", ":", "case", "WebAssembly", "::", "CONST_F64", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::CONST_I32", "WebAssembly::CONST_I64", "WebAssembly::CONST_F32", "WebAssembly::CONST_F64" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "IsDesirableToPromoteOp", "(", "SDValue", "Op", ",", "EVT", "&", "PVT", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "i16", ")", "return", "false", ";", "bool", "Promote", "=", "false", ";", "bool", "Commute", "=", "false", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "Promote", "=", "true", ";", "break", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "{", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "if", "(", "MayFoldLoad", "(", "N0", ")", "&&", "MayFoldIntoStore", "(", "Op", ")", ")", "return", "false", ";", "Promote", "=", "true", ";", "break", ";", "}", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "Commute", "=", "true", ";", "case", "ISD", "::", "SUB", ":", "{", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "Commute", "&&", "MayFoldLoad", "(", "N1", ")", ")", "return", "false", ";", "if", "(", "MayFoldLoad", "(", "N0", ")", "&&", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "N1", ")", "||", "MayFoldIntoStore", "(", "Op", ")", ")", ")", "return", "false", ";", "if", "(", "MayFoldLoad", "(", "N1", ")", "&&", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "N0", ")", "||", "MayFoldIntoStore", "(", "Op", ")", ")", ")", "return", "false", ";", "Promote", "=", "true", ";", "}", "}", "PVT", "=", "MVT", "::", "i32", ";", "return", "Promote", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "." ]

[ "X86", "X86", "MVT::i16", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::SHL", "ISD::SRL", "0", "ISD::ADD", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::SUB", "0", "1", "MVT::i32" ]

[]

[ "<s>", "const", "HexagonSubtarget", "*", "HexagonTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "AttributeList", "FnAttrs", "=", "F", ".", "getAttributes", "(", ")", ";", "Attribute", "CPUAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "if", "(", "FnAttrs", ".", "hasFnAttribute", "(", "\"unsafe-fp-math\"", ")", "&&", "F", ".", "getFnAttribute", "(", "\"unsafe-fp-math\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "FS", "=", "FS", ".", "empty", "(", ")", "?", "\"+unsafe-fp\"", ":", "\"+unsafe-fp,\"", "+", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "HexagonSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"target-cpu\"", "\"target-features\"", "\"unsafe-fp-math\"", "\"unsafe-fp-math\"", "\"true\"", "\"+unsafe-fp\"", "\"+unsafe-fp,\"", "Hexagon" ]

[]

[ "<s>", "InstructionCost", "ARMTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", ")", "{", "if", "(", "(", "Opcode", "==", "Instruction", "::", "SDiv", "||", "Opcode", "==", "Instruction", "::", "UDiv", "||", "Opcode", "==", "Instruction", "::", "SRem", "||", "Opcode", "==", "Instruction", "::", "URem", ")", "&&", "Idx", "==", "1", ")", "return", "0", ";", "if", "(", "Opcode", "==", "Instruction", "::", "And", ")", "{", "if", "(", "Imm", "==", "255", "||", "Imm", "==", "65535", ")", "return", "0", ";", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ",", "getIntImmCost", "(", "~", "Imm", ",", "Ty", ",", "CostKind", ")", ")", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Add", ")", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ",", "getIntImmCost", "(", "-", "Imm", ",", "Ty", ",", "CostKind", ")", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "ICmp", "&&", "Imm", ".", "isNegative", "(", ")", "&&", "Ty", "->", "getIntegerBitWidth", "(", ")", "==", "32", ")", "{", "int64_t", "NegImm", "=", "-", "Imm", ".", "getSExtValue", "(", ")", ";", "if", "(", "ST", "->", "isThumb2", "(", ")", "&&", "NegImm", "<", "1", "<<", "12", ")", "return", "0", ";", "if", "(", "ST", "->", "isThumb", "(", ")", "&&", "NegImm", "<", "1", "<<", "8", ")", "return", "0", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Xor", "&&", "Imm", ".", "isAllOnesValue", "(", ")", ")", "return", "0", ";", "if", "(", "Inst", "&&", "(", "(", "ST", "->", "hasV6Ops", "(", ")", "&&", "!", "ST", "->", "isThumb", "(", ")", ")", "||", "ST", "->", "isThumb2", "(", ")", ")", "&&", "Ty", "->", "getIntegerBitWidth", "(", ")", "<=", "32", ")", "{", "if", "(", "isSSATMinMaxPattern", "(", "Inst", ",", "Imm", ")", "||", "(", "isa", "<", "ICmpInst", ">", "(", "Inst", ")", "&&", "Inst", "->", "hasOneUse", "(", ")", "&&", "isSSATMinMaxPattern", "(", "cast", "<", "Instruction", ">", "(", "*", "Inst", "->", "user_begin", "(", ")", ")", ",", "Imm", ")", ")", ")", "return", "0", ";", "}", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "ARM", "ARM", "1", "0", "255", "65535", "0", "32", "1", "12", "0", "1", "8", "0", "0", "32", "0" ]

[]

[ "<s>", "bool", "function_resolver", "::", "check_gp_argument", "(", "unsigned", "int", "nops", ",", "unsigned", "int", "&", "i", ",", "unsigned", "int", "&", "nargs", ")", "{", "i", "=", "0", ";", "if", "(", "pred", "!=", "PRED_none", ")", "{", "gcc_assert", "(", "nops", "!=", "1", "||", "pred", "!=", "PRED_m", ")", ";", "nargs", "=", "nops", "+", "1", ";", "if", "(", "!", "check_num_arguments", "(", "nargs", ")", "||", "!", "require_vector_type", "(", "i", ",", "VECTOR_TYPE_svbool_t", ")", ")", "return", "false", ";", "i", "+=", "1", ";", "}", "else", "{", "nargs", "=", "nops", ";", "if", "(", "!", "check_num_arguments", "(", "nargs", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "If", "the", "function", "is", "predicated", ",", "check", "that", "the", "first", "argument", "is", "a", "suitable", "governing", "predicate", ".", "Also", "check", "that", "there", "are", "NOPS", "further", "arguments", "after", "any", "governing", "predicate", ",", "but", "do", "n't", "check", "what", "they", "are", ".", "Return", "true", "on", "success", ",", "otherwise", "report", "a", "suitable", "error", ".", "When", "returning", "true", ":", "-", "set", "I", "to", "the", "number", "of", "the", "first", "unchecked", "argument", ".", "-", "set", "NARGS", "to", "the", "total", "number", "of", "arguments", "." ]

[ "aarch64", "0", "1", "1", "1" ]

[]

[ "<s>", "static", "bool", "tilegx_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_TImode", ":", "return", "true", ";", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", "." ]

[ "tilegx" ]

[]

[ "<s>", "void", "SPURegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "dl", "=", "II", "->", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "MachineOperand", "&", "SPOp", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "int", "FrameIndex", "=", "SPOp", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "unsigned", "OpNo", "=", "1", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SPU", "::", "AIr32", "||", "MI", ".", "getOpcode", "(", ")", "==", "SPU", "::", "ILAr32", ")", "OpNo", "=", "2", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "Offset", "+=", "MO", ".", "getImm", "(", ")", "+", "MFI", "->", "getStackSize", "(", ")", "+", "SPUFrameInfo", "::", "minStackSize", "(", ")", ";", "assert", "(", "(", "Offset", "&", "0xf", ")", "==", "0", "&&", "\"16-byte alignment violated in eliminateFrameIndex\"", ")", ";", "SPOp", ".", "ChangeToRegister", "(", "SPU", "::", "R1", ",", "false", ")", ";", "if", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "SPU", "::", "AIr32", "&&", "!", "isInt", "<", "10", ">", "(", "Offset", ")", ")", "||", "!", "isInt", "<", "14", ">", "(", "Offset", ")", ")", "{", "int", "newOpcode", "=", "convertDFormToXForm", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "tmpReg", "=", "findScratchRegister", "(", "II", ",", "RS", ",", "&", "SPU", "::", "R32CRegClass", ",", "SPAdj", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "ILr32", ")", ",", "tmpReg", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "newOpcode", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "tmpReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "else", "{", "MO", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "CellSPU", "SPU", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "SPU::AIr32", "SPU::ILAr32", "2", "SPU", "0xf", "0", "\"16-byte alignment violated in eliminateFrameIndex\"", "SPU::R1", "SPU::AIr32", "10", "14", "SPU::R32CRegClass", "SPU::ILr32", "0", "SPU::R1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Prepare control-flow for ISel\"", ";", "}", "</s>" ]

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

[ "TVM", "\"Prepare control-flow for ISel\"" ]

[]

[ "<s>", "void", "*", "aarch64_init_cost", "(", "class", "loop", "*", ")", "{", "return", "new", "aarch64_vector_costs", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_INIT_COST", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "frv_start_packet", "(", "void", ")", "{", "enum", "frv_insn_group", "group", ";", "memset", "(", "frv_packet", ".", "regstate", ",", "0", ",", "sizeof", "(", "frv_packet", ".", "regstate", ")", ")", ";", "frv_packet", ".", "num_mems", "=", "0", ";", "frv_packet", ".", "num_insns", "=", "0", ";", "for", "(", "group", "=", "GROUP_I", ";", "group", "<", "NUM_GROUPS", ";", "group", "=", "(", "enum", "frv_insn_group", ")", "(", "group", "+", "1", ")", ")", "frv_packet", ".", "groups", "[", "group", "]", ".", "num_insns", "=", "0", ";", "}", "</s>" ]

[ "Initialize", "frv_packet", "for", "the", "start", "of", "a", "new", "packet", "." ]

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

[]

[ "<s>", "void", "CJGAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "if", "(", "IsPCRel", ")", "{", "llvm_unreachable", "(", "\"PC Rel not currently implemented\"", ")", ";", "}", "if", "(", "!", "Value", ")", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "return", ";", "}", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "assert", "(", "Value", "%", "4", "==", "0", "&&", "\"The destination address is not aligned to a word\"", ")", ";", "Data", "[", "Offset", "]", "=", "Value", "&", "0xFF", ";", "Data", "[", "Offset", "+", "1", "]", "=", "uint8_t", "(", "(", "Value", ">>", "8", ")", "&", "0xFF", ")", ";", "return", ";", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "CJG", "CJG", "\"PC Rel not currently implemented\"", "\"Invalid fixup offset!\"", "4", "0", "\"The destination address is not aligned to a word\"", "0xFF", "1", "8", "0xFF" ]

[]

[ "<s>", "static", "void", "ft32_compute_frame", "(", "void", ")", "{", "int", "stack_alignment", "=", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ";", "int", "padding_locals", ";", "int", "regno", ";", "cfun", "->", "machine", "->", "local_vars_size", "=", "get_frame_size", "(", ")", ";", "padding_locals", "=", "cfun", "->", "machine", "->", "local_vars_size", "%", "stack_alignment", ";", "if", "(", "padding_locals", ")", "padding_locals", "=", "stack_alignment", "-", "padding_locals", ";", "cfun", "->", "machine", "->", "local_vars_size", "+=", "padding_locals", ";", "cfun", "->", "machine", "->", "callee_saved_reg_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_regs", "[", "regno", "]", ")", ")", "cfun", "->", "machine", "->", "callee_saved_reg_size", "+=", "4", ";", "cfun", "->", "machine", "->", "size_for_adjusting_sp", "=", "0", "+", "cfun", "->", "machine", "->", "local_vars_size", "+", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "crtl", "->", "outgoing_args_size", ":", "0", ")", ";", "}", "</s>" ]

[ "Compute", "the", "size", "of", "the", "local", "area", "and", "the", "size", "to", "be", "adjusted", "by", "the", "*", "prologue", "and", "epilogue", "." ]

[ "ft32", "0", "0", "4", "0", "0" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createAMDGPUPrintfRuntimeBinding", "(", ")", ")", ";", "addPass", "(", "createAMDGPUFixFunctionBitcastsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUPropagateAttributesEarlyPass", "(", "&", "TM", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPULowerIntrinsicsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerLegacyPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "addPass", "(", "createR600OpenCLImageTypeLoweringPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUOpenCLEnqueuedBlockLoweringPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInferAddressSpacesPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUPromoteAlloca", "(", ")", ")", ";", "if", "(", "EnableSROA", ")", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "if", "(", "EnableScalarIRPasses", ")", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "if", "(", "EnableAMDGPUAliasAnalysis", ")", "{", "addPass", "(", "createAMDGPUAAWrapperPass", "(", ")", ")", ";", "addPass", "(", "createExternalAAWrapperPass", "(", "[", "]", "(", "Pass", "&", "P", ",", "Function", "&", ",", "AAResults", "&", "AAR", ")", "{", "if", "(", "auto", "*", "WrapperPass", "=", "P", ".", "getAnalysisIfAvailable", "<", "AMDGPUAAWrapperPass", ">", "(", ")", ")", "AAR", ".", "addAAResult", "(", "WrapperPass", "->", "getResult", "(", ")", ")", ";", "}", ")", ")", ";", "}", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "addPass", "(", "createAMDGPUCodeGenPreparePass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableScalarIRPasses", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "R600", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldClusterMemOps", "(", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps1", ",", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps2", ",", "unsigned", "NumLoads", ",", "unsigned", "NumBytes", ")", "const", "{", "assert", "(", "BaseOps1", ".", "size", "(", ")", "==", "1", "&&", "BaseOps2", ".", "size", "(", ")", "==", "1", ")", ";", "const", "MachineOperand", "&", "BaseOp1", "=", "*", "BaseOps1", ".", "front", "(", ")", ";", "const", "MachineOperand", "&", "BaseOp2", "=", "*", "BaseOps2", ".", "front", "(", ")", ";", "const", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOp1", ".", "getParent", "(", ")", ";", "const", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOp2", ".", "getParent", "(", ")", ";", "if", "(", "BaseOp1", ".", "getType", "(", ")", "!=", "BaseOp2", ".", "getType", "(", ")", ")", "return", "false", ";", "assert", "(", "(", "BaseOp1", ".", "isReg", "(", ")", "||", "BaseOp1", ".", "isFI", "(", ")", ")", "&&", "\"Only base registers and frame indices are supported.\"", ")", ";", "if", "(", "BaseOp1", ".", "isReg", "(", ")", "&&", "BaseOp1", ".", "getReg", "(", ")", "!=", "BaseOp2", ".", "getReg", "(", ")", ")", "return", "false", ";", "if", "(", "NumLoads", ">", "2", ")", "return", "false", ";", "if", "(", "!", "isPairableLdStInst", "(", "FirstLdSt", ")", "||", "!", "isPairableLdStInst", "(", "SecondLdSt", ")", ")", "return", "false", ";", "unsigned", "FirstOpc", "=", "FirstLdSt", ".", "getOpcode", "(", ")", ";", "unsigned", "SecondOpc", "=", "SecondLdSt", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "canPairLdStOpc", "(", "FirstOpc", ",", "SecondOpc", ")", ")", "return", "false", ";", "if", "(", "!", "isCandidateToMergeOrPair", "(", "FirstLdSt", ")", "||", "!", "isCandidateToMergeOrPair", "(", "SecondLdSt", ")", ")", "return", "false", ";", "int64_t", "Offset1", "=", "FirstLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "FirstOpc", ")", "&&", "!", "scaleOffset", "(", "FirstOpc", ",", "Offset1", ")", ")", "return", "false", ";", "int64_t", "Offset2", "=", "SecondLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "SecondOpc", ")", "&&", "!", "scaleOffset", "(", "SecondOpc", ",", "Offset2", ")", ")", "return", "false", ";", "if", "(", "Offset1", ">", "63", "||", "Offset1", "<", "-", "64", ")", "return", "false", ";", "if", "(", "BaseOp1", ".", "isFI", "(", ")", ")", "{", "assert", "(", "(", "!", "BaseOp1", ".", "isIdenticalTo", "(", "BaseOp2", ")", "||", "Offset1", "<=", "Offset2", ")", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFrameInfo", "(", ")", ";", "return", "shouldClusterFI", "(", "MFI", ",", "BaseOp1", ".", "getIndex", "(", ")", ",", "Offset1", ",", "FirstOpc", ",", "BaseOp2", ".", "getIndex", "(", ")", ",", "Offset2", ",", "SecondOpc", ")", ";", "}", "assert", "(", "Offset1", "<=", "Offset2", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "return", "Offset1", "+", "1", "==", "Offset2", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "1", "\"Only base registers and frame indices are supported.\"", "2", "2", "2", "63", "64", "\"Caller should have ordered offsets.\"", "\"Caller should have ordered offsets.\"", "1" ]

[]

[ "<s>", "static", "bool", "sparc_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "if", "(", "sparc_tls_referenced_p", "(", "x", ")", ")", "return", "false", ";", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "return", "true", ";", "if", "(", "TARGET_VIS", "&&", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", "&&", "(", "const_zero_operand", "(", "x", ",", "mode", ")", "||", "const_all_ones_operand", "(", "x", ",", "mode", ")", ")", ")", "return", "true", ";", "return", "false", ";", "case", "CONST_VECTOR", ":", "if", "(", "TARGET_VIS", "&&", "(", "const_zero_operand", "(", "x", ",", "mode", ")", "||", "const_all_ones_operand", "(", "x", ",", "mode", ")", ")", ")", "return", "true", ";", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "rtx", "stv_expand_builtin", "(", "insn_code", "icode", ",", "rtx", "*", "op", ",", "machine_mode", "tmode", ",", "machine_mode", "smode", ")", "{", "op", "[", "2", "]", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op", "[", "2", "]", ")", ";", "if", "(", "icode", "==", "CODE_FOR_altivec_stvx_v2df", "||", "icode", "==", "CODE_FOR_altivec_stvx_v2di", "||", "icode", "==", "CODE_FOR_altivec_stvx_v4sf", "||", "icode", "==", "CODE_FOR_altivec_stvx_v4si", "||", "icode", "==", "CODE_FOR_altivec_stvx_v8hi", "||", "icode", "==", "CODE_FOR_altivec_stvx_v16qi", ")", "{", "rtx", "rawaddr", ";", "if", "(", "op", "[", "1", "]", "==", "const0_rtx", ")", "rawaddr", "=", "op", "[", "2", "]", ";", "else", "{", "op", "[", "1", "]", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op", "[", "1", "]", ")", ";", "rawaddr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "op", "[", "2", "]", ",", "op", "[", "1", "]", ")", ";", "}", "rtx", "addr", "=", "gen_rtx_AND", "(", "Pmode", ",", "rawaddr", ",", "gen_rtx_CONST_INT", "(", "Pmode", ",", "-", "16", ")", ")", ";", "addr", "=", "gen_rtx_MEM", "(", "tmode", ",", "addr", ")", ";", "op", "[", "0", "]", "=", "copy_to_mode_reg", "(", "tmode", ",", "op", "[", "0", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "addr", ",", "op", "[", "0", "]", ")", ")", ";", "}", "else", "if", "(", "icode", "==", "CODE_FOR_vsx_stxvrbx", "||", "icode", "==", "CODE_FOR_vsx_stxvrhx", "||", "icode", "==", "CODE_FOR_vsx_stxvrwx", "||", "icode", "==", "CODE_FOR_vsx_stxvrdx", ")", "{", "rtx", "truncrtx", "=", "gen_rtx_TRUNCATE", "(", "tmode", ",", "op", "[", "0", "]", ")", ";", "op", "[", "0", "]", "=", "copy_to_mode_reg", "(", "E_TImode", ",", "truncrtx", ")", ";", "rtx", "addr", ";", "if", "(", "op", "[", "1", "]", "==", "const0_rtx", ")", "addr", "=", "gen_rtx_MEM", "(", "Pmode", ",", "op", "[", "2", "]", ")", ";", "else", "{", "op", "[", "1", "]", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op", "[", "1", "]", ")", ";", "addr", "=", "gen_rtx_MEM", "(", "tmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "op", "[", "2", "]", ",", "op", "[", "1", "]", ")", ")", ";", "}", "rtx", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "addr", ",", "op", "[", "0", "]", ")", ";", "if", "(", "pat", ")", "emit_insn", "(", "pat", ")", ";", "}", "else", "{", "if", "(", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", "(", "op", "[", "0", "]", ",", "smode", ")", ")", "op", "[", "0", "]", "=", "copy_to_mode_reg", "(", "smode", ",", "op", "[", "0", "]", ")", ";", "rtx", "addr", ";", "if", "(", "op", "[", "1", "]", "==", "const0_rtx", ")", "addr", "=", "gen_rtx_MEM", "(", "tmode", ",", "op", "[", "2", "]", ")", ";", "else", "{", "op", "[", "1", "]", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op", "[", "1", "]", ")", ";", "addr", "=", "gen_rtx_MEM", "(", "tmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "op", "[", "2", "]", ",", "op", "[", "1", "]", ")", ")", ";", "}", "rtx", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "addr", ",", "op", "[", "0", "]", ")", ";", "if", "(", "pat", ")", "emit_insn", "(", "pat", ")", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "an", "AltiVec", "vector", "store", "builtin", ",", "and", "return", "the", "expanded", "rtx", "." ]

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

[]

[ "<s>", "static", "void", "initialize_aarch64_code_model", "(", "struct", "gcc_options", "*", "opts", ")", "{", "if", "(", "opts", "->", "x_flag_pic", ")", "{", "switch", "(", "opts", "->", "x_aarch64_cmodel_var", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "aarch64_cmodel", "=", "AARCH64_CMODEL_TINY_PIC", ";", "break", ";", "case", "AARCH64_CMODEL_SMALL", ":", "aarch64_cmodel", "=", "(", "flag_pic", "==", "2", "?", "AARCH64_CMODEL_SMALL_PIC", ":", "AARCH64_CMODEL_SMALL_SPIC", ")", ";", "aarch64_cmodel", "=", "AARCH64_CMODEL_SMALL_PIC", ";", "break", ";", "case", "AARCH64_CMODEL_LARGE", ":", "sorry", "(", "\"code model %qs with %<-f%s%>\"", ",", "\"large\"", ",", "opts", "->", "x_flag_pic", ">", "1", "?", "\"PIC\"", ":", "\"pic\"", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "aarch64_cmodel", "=", "opts", "->", "x_aarch64_cmodel_var", ";", "}", "</s>" ]

[ "A", "checking", "mechanism", "for", "the", "implementation", "of", "the", "various", "code", "models", "." ]

[ "aarch64", "2", "\"code model %qs with %<-f%s%>\"", "\"large\"", "1", "\"PIC\"", "\"pic\"" ]

[]

[ "<s>", "static", "bool", "avr_address_tiny_pm_p", "(", "rtx", "x", ")", "{", "if", "(", "CONST", "==", "GET_CODE", "(", "x", ")", ")", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "AVR_SYMBOL_FLAG_TINY_PM", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "rtx", "X", "is", "a", "CONST", "or", "SYMBOL_REF", "with", "progmem", ".", "This", "must", "be", "used", "for", "AVR_TINY", "only", "because", "on", "other", "cores", "the", "flash", "memory", "is", "not", "visible", "in", "the", "RAM", "address", "range", "and", "can", "not", "be", "read", "by", ",", "say", ",", "LD", "instruction", "." ]

[ "avr", "0", "0" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "SIStackID", "::", "SGPR_SPILL", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "SIStackID::SGPR_SPILL", "AMDGPU::M0", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "O", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "k_Token", ":", "O", "<<", "\"Token: \\\"\"", "<<", "getToken", "(", ")", "<<", "\"\\\"\"", ";", "break", ";", "case", "k_Register", ":", "O", "<<", "\"Register: \"", "<<", "getReg", "(", ")", ";", "break", ";", "case", "k_Immediate", ":", "O", "<<", "\"Immediate: \\\"\"", "<<", "*", "getImm", "(", ")", "<<", "\"\\\"\"", ";", "break", ";", "case", "k_Memri", ":", "{", "O", "<<", "\"Memri: \\\"\"", "<<", "getReg", "(", ")", "<<", "'+'", "<<", "*", "getImm", "(", ")", "<<", "\"\\\"\"", ";", "break", ";", "}", "}", "O", "<<", "\"\\n\"", ";", "}", "</s>" ]

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

[ "MCS51", "\"Token: \\\"\"", "\"\\\"\"", "\"Register: \"", "\"Immediate: \\\"\"", "\"\\\"\"", "\"Memri: \\\"\"", "\"\\\"\"", "\"\\n\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SIInstrInfo", "::", "getOpRegClass", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "MI", ".", "isVariadic", "(", ")", "||", "OpNo", ">=", "Desc", ".", "getNumOperands", "(", ")", "||", "Desc", ".", "OpInfo", "[", "OpNo", "]", ".", "RegClass", "==", "-", "1", ")", "{", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", ".", "isVirtual", "(", ")", ")", "return", "MRI", ".", "getRegClass", "(", "Reg", ")", ";", "return", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "}", "unsigned", "RCID", "=", "Desc", ".", "OpInfo", "[", "OpNo", "]", ".", "RegClass", ";", "RCID", "=", "adjustAllocatableRegClass", "(", "ST", ",", "MRI", ",", "Desc", ",", "RCID", ",", "true", ")", ";", "return", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "}", "</s>" ]

[ "Return", "the", "correct", "register", "class", "for", "OpNo", "." ]

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

[]

[ "<s>", "unsigned", "getPrefetchDistance", "(", ")", "const", "{", "return", "PrefetchDistance", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "prefetch", "distance", "in", "terms", "of", "instructions", "." ]

[ "AArch64" ]

[]

[ "<s>", "EVT", "AArch64TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "bool", "CanImplicitFloat", "=", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "bool", "CanUseNEON", "=", "Subtarget", "->", "hasNEON", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "CanUseFP", "=", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "IsSmallMemset", "=", "IsMemset", "&&", "Size", "<", "32", ";", "auto", "AlignmentIsAcceptable", "=", "[", "&", "]", "(", "EVT", "VT", ",", "unsigned", "AlignCheck", ")", "{", "if", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "AlignCheck", ")", ")", "return", "true", ";", "bool", "Fast", ";", "return", "allowsMisalignedMemoryAccesses", "(", "VT", ",", "0", ",", "1", ",", "MachineMemOperand", "::", "MONone", ",", "&", "Fast", ")", "&&", "Fast", ";", "}", ";", "if", "(", "CanUseNEON", "&&", "IsMemset", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "v2i64", ",", "16", ")", ")", "return", "MVT", "::", "v2i64", ";", "if", "(", "CanUseFP", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "f128", ",", "16", ")", ")", "return", "MVT", "::", "f128", ";", "if", "(", "Size", ">=", "8", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i64", ",", "8", ")", ")", "return", "MVT", "::", "i64", ";", "if", "(", "Size", ">=", "4", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i32", ",", "4", ")", ")", "return", "MVT", "::", "i32", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "AArch64", "AArch64", "32", "0", "1", "MVT::v2i64", "16", "MVT::v2i64", "MVT::f128", "16", "MVT::f128", "8", "MVT::i64", "8", "MVT::i64", "4", "MVT::i32", "4", "MVT::i32", "MVT::Other" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "usesConstantBus", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MachineOperand", "&", "MO", ",", "unsigned", "OpSize", ")", "const", "{", "if", "(", "isLiteralConstant", "(", "MO", ",", "OpSize", ")", ")", "return", "true", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isUse", "(", ")", ")", "return", "false", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "return", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ")", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "FLAT_SCR", ")", ")", "return", "true", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "EXEC", ")", "return", "true", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "M0", "||", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC", "||", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "SGPR_64RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operand", "uses", "the", "constant", "bus", "." ]

[ "AMDGPU", "SI", "AMDGPU::FLAT_SCR", "AMDGPU::EXEC", "AMDGPU::M0", "AMDGPU::VCC", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_64RegClass" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldScalarizeBinop", "(", "SDValue", "VecOp", ")", "const", "{", "EVT", "VecVT", "=", "VecOp", ".", "getValueType", "(", ")", ";", "if", "(", "!", "isOperationLegalOrCustomOrPromote", "(", "VecOp", ".", "getOpcode", "(", ")", ",", "VecVT", ")", ")", "return", "true", ";", "EVT", "ScalarVT", "=", "VecVT", ".", "getScalarType", "(", ")", ";", "return", "isOperationLegalOrCustomOrPromote", "(", "VecOp", ".", "getOpcode", "(", ")", ",", "ScalarVT", ")", ";", "}", "</s>" ]

[ "Scalar", "ops", "always", "have", "equal", "or", "better", "analysis/performance/power", "than", "the", "vector", "equivalent", ",", "so", "this", "always", "makes", "sense", "if", "the", "scalar", "op", "is", "supported", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "rtx", "v850_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "func", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "RV_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBCALL_VALUE", "." ]

[ "v850" ]

[]

[ "<s>", "CCAssignFn", "*", "ARMFastISel", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "Return", ",", "bool", "isVarArg", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "if", "(", "Subtarget", "->", "hasVFP2Base", "(", ")", "&&", "!", "isVarArg", ")", "{", "if", "(", "!", "Subtarget", "->", "isAAPCS_ABI", "(", ")", ")", "return", "(", "Return", "?", "RetFastCC_ARM_APCS", ":", "FastCC_ARM_APCS", ")", ";", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "}", "LLVM_FALLTHROUGH", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Subtarget", "->", "isAAPCS_ABI", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "hasVFP2Base", "(", ")", "&&", "TM", ".", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Hard", "&&", "!", "isVarArg", ")", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "else", "return", "(", "Return", "?", "RetCC_ARM_AAPCS", ":", "CC_ARM_AAPCS", ")", ";", "}", "else", "{", "return", "(", "Return", "?", "RetCC_ARM_APCS", ":", "CC_ARM_APCS", ")", ";", "}", "case", "CallingConv", "::", "ARM_AAPCS_VFP", ":", "case", "CallingConv", "::", "Swift", ":", "if", "(", "!", "isVarArg", ")", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "CallingConv", "::", "ARM_AAPCS", ":", "return", "(", "Return", "?", "RetCC_ARM_AAPCS", ":", "CC_ARM_AAPCS", ")", ";", "case", "CallingConv", "::", "ARM_APCS", ":", "return", "(", "Return", "?", "RetCC_ARM_APCS", ":", "CC_ARM_APCS", ")", ";", "case", "CallingConv", "::", "GHC", ":", "if", "(", "Return", ")", "report_fatal_error", "(", "\"Can't return in GHC call convention\"", ")", ";", "else", "return", "CC_ARM_APCS_GHC", ";", "case", "CallingConv", "::", "CFGuard_Check", ":", "return", "(", "Return", "?", "RetCC_ARM_AAPCS", ":", "CC_ARM_Win32_CFGuard_Check", ")", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "ARM", "ARM", "\"Unsupported calling convention\"", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "\"Can't return in GHC call convention\"", "ARM", "ARM", "ARM" ]

[]

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

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

[ "CellSPU", "SPU", "SPU::R32CRegClass" ]

[]

[ "<s>", "static", "rtx", "m68k_unwrap_symbol_1", "(", "rtx", "orig", ",", "bool", "unwrap_reloc32_p", ",", "enum", "m68k_reloc", "*", "reloc_ptr", ")", "{", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST", ")", "{", "rtx", "x", ";", "enum", "m68k_reloc", "dummy", ";", "x", "=", "XEXP", "(", "orig", ",", "0", ")", ";", "if", "(", "reloc_ptr", "==", "NULL", ")", "reloc_ptr", "=", "&", "dummy", ";", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "||", "GET_CODE", "(", "x", ")", "==", "MINUS", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "{", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_RELOC16", ":", "orig", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "*", "reloc_ptr", "=", "(", "enum", "m68k_reloc", ")", "INTVAL", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", ";", "break", ";", "case", "UNSPEC_RELOC32", ":", "if", "(", "unwrap_reloc32_p", ")", "{", "orig", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "*", "reloc_ptr", "=", "(", "enum", "m68k_reloc", ")", "INTVAL", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "orig", ";", "}", "</s>" ]

[ "Helper", "for", "m68k_unwrap_symbol", ".", "Also", ",", "if", "unwrapping", "was", "successful", "(", "that", "is", "if", "(", "ORIG", "!", "=", "<", "return", "value", ">", ")", ")", ",", "sets", "*", "RELOC_PTR", "to", "relocation", "type", "for", "the", "symbol", "." ]

[ "m68k", "0", "1", "0", "1", "0", "0", "0", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "inline", "tree", "def_builtin_const2", "(", "HOST_WIDE_INT", "mask", ",", "const", "char", "*", "name", ",", "enum", "ix86_builtin_func_type", "tcode", ",", "enum", "ix86_builtins", "code", ")", "{", "tree", "decl", "=", "def_builtin2", "(", "mask", ",", "name", ",", "tcode", ",", "code", ")", ";", "if", "(", "decl", ")", "TREE_READONLY", "(", "decl", ")", "=", "1", ";", "else", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "const_p", "=", "true", ";", "return", "decl", ";", "}", "</s>" ]

[ "Like", "def_builtin", ",", "but", "also", "marks", "the", "function", "decl", "``", "const", "''", "." ]

[ "i386", "1" ]

[]

[ "<s>", "GCNSubtarget", "&", "GCNSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+load-store-opt,+sram-ecc,+xnack,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", ";", "if", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "FullFS", "+=", "\"+fp64-fp16-denormals,\"", ";", "}", "else", "{", "FullFS", "+=", "\"-fp32-denormals,\"", ";", "}", "FullFS", "+=", "\"+enable-prt-strict-null,\"", ";", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "FullFS", ")", ";", "assert", "(", "!", "hasFP64", "(", ")", "||", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", ")", ";", "if", "(", "!", "hasAddr64", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", ")", "{", "FlatForGlobal", "=", "true", ";", "}", "if", "(", "MaxPrivateElementSize", "==", "0", ")", "MaxPrivateElementSize", "=", "4", ";", "if", "(", "LDSBankCount", "==", "0", ")", "LDSBankCount", "=", "32", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "if", "(", "LocalMemorySize", "==", "0", ")", "LocalMemorySize", "=", "32768", ";", "if", "(", "!", "HasMovrel", "&&", "!", "HasVGPRIndexMode", ")", "HasMovrel", "=", "true", ";", "}", "if", "(", "WavefrontSize", "==", "0", ")", "WavefrontSize", "=", "64", ";", "HasFminFmaxLegacy", "=", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "if", "(", "DoesNotSupportXNACK", "&&", "EnableXNACK", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureXNACK", ")", ";", "EnableXNACK", "=", "false", ";", "}", "if", "(", "DoesNotSupportSRAMECC", "&&", "EnableSRAMECC", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureSRAMECC", ")", ";", "EnableSRAMECC", "=", "false", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "AMDGPU", "256", "\"+promote-alloca,+load-store-opt,+sram-ecc,+xnack,\"", "\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", "AMDGPU", "\"+fp64-fp16-denormals,\"", "\"-fp32-denormals,\"", "\"+enable-prt-strict-null,\"", "AMDGPU", "\"flat-for-global\"", "0", "4", "0", "32", "0", "32768", "0", "64", "AMDGPU", "AMDGPU::FeatureXNACK", "AMDGPU::FeatureSRAMECC" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "getRegSequenceLikeInputs", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "DefIdx", ",", "SmallVectorImpl", "<", "RegSubRegPairAndIdx", ">", "&", "InputRegs", ")", "const", "{", "assert", "(", "DefIdx", "<", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "&&", "\"Invalid definition index\"", ")", ";", "assert", "(", "MI", ".", "isRegSequenceLike", "(", ")", "&&", "\"Invalid kind of instruction\"", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VMOVDRR", ":", "const", "MachineOperand", "*", "MOReg", "=", "&", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "MOReg", "->", "isUndef", "(", ")", ")", "InputRegs", ".", "push_back", "(", "RegSubRegPairAndIdx", "(", "MOReg", "->", "getReg", "(", ")", ",", "MOReg", "->", "getSubReg", "(", ")", ",", "ARM", "::", "ssub_0", ")", ")", ";", "MOReg", "=", "&", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "MOReg", "->", "isUndef", "(", ")", ")", "InputRegs", ".", "push_back", "(", "RegSubRegPairAndIdx", "(", "MOReg", "->", "getReg", "(", ")", ",", "MOReg", "->", "getSubReg", "(", ")", ",", "ARM", "::", "ssub_1", ")", ")", ";", "return", "true", ";", "}", "llvm_unreachable", "(", "\"Target dependent opcode missing\"", ")", ";", "}", "</s>" ]

[ "Target-dependent", "implementation", "of", "getRegSequenceInputs", "." ]

[ "ARM", "ARM", "\"Invalid definition index\"", "\"Invalid kind of instruction\"", "ARM::VMOVDRR", "1", "ARM::ssub_0", "2", "ARM::ssub_1", "\"Target dependent opcode missing\"" ]

[]

[ "<s>", "void", "function_expander", "::", "prepare_prefetch_operands", "(", ")", "{", "unsigned", "int", "prfop", "=", "INTVAL", "(", "args", ".", "last", "(", ")", ")", ";", "args", ".", "quick_push", "(", "GEN_INT", "(", "(", "prfop", "&", "8", ")", "!=", "0", ")", ")", ";", "args", ".", "quick_push", "(", "GEN_INT", "(", "(", "(", "prfop", ">>", "1", ")", "&", "3", ")", "+", "1", ")", ")", ";", "}", "</s>" ]

[ "The", "final", "argument", "is", "an", "immediate", "svprfop", "value", ".", "Add", "two", "fake", "arguments", "to", "represent", "the", "rw", "and", "locality", "operands", "of", "a", "PREFETCH", "rtx", "." ]

[ "aarch64", "8", "0", "1", "3", "1" ]

[]

[ "<s>", "static", "int", "getMemScale", "(", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode has unknown scale!\"", ")", ";", "case", "AArch64", "::", "LDRBBui", ":", "case", "AArch64", "::", "LDURBBi", ":", "case", "AArch64", "::", "LDRSBWui", ":", "case", "AArch64", "::", "LDURSBWi", ":", "case", "AArch64", "::", "STRBBui", ":", "case", "AArch64", "::", "STURBBi", ":", "return", "1", ";", "case", "AArch64", "::", "LDRHHui", ":", "case", "AArch64", "::", "LDURHHi", ":", "case", "AArch64", "::", "LDRSHWui", ":", "case", "AArch64", "::", "LDURSHWi", ":", "case", "AArch64", "::", "STRHHui", ":", "case", "AArch64", "::", "STURHHi", ":", "return", "2", ";", "case", "AArch64", "::", "LDRSui", ":", "case", "AArch64", "::", "LDURSi", ":", "case", "AArch64", "::", "LDRSWui", ":", "case", "AArch64", "::", "LDURSWi", ":", "case", "AArch64", "::", "LDRWui", ":", "case", "AArch64", "::", "LDURWi", ":", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STURSi", ":", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "STURWi", ":", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "LDPSWi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "STPWi", ":", "return", "4", ";", "case", "AArch64", "::", "LDRDui", ":", "case", "AArch64", "::", "LDURDi", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDURXi", ":", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STURDi", ":", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STURXi", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "STPXi", ":", "return", "8", ";", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "STRQui", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "STPQi", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Scaling", "factor", "for", "(", "scaled", "or", "unscaled", ")", "load", "or", "store", "." ]

[ "AArch64", "\"Opcode has unknown scale!\"", "AArch64::LDRBBui", "AArch64::LDURBBi", "AArch64::LDRSBWui", "AArch64::LDURSBWi", "AArch64::STRBBui", "AArch64::STURBBi", "1", "AArch64::LDRHHui", "AArch64::LDURHHi", "AArch64::LDRSHWui", "AArch64::LDURSHWi", "AArch64::STRHHui", "AArch64::STURHHi", "2", "AArch64::LDRSui", "AArch64::LDURSi", "AArch64::LDRSWui", "AArch64::LDURSWi", "AArch64::LDRWui", "AArch64::LDURWi", "AArch64::STRSui", "AArch64::STURSi", "AArch64::STRWui", "AArch64::STURWi", "AArch64::LDPSi", "AArch64::LDPSWi", "AArch64::LDPWi", "AArch64::STPSi", "AArch64::STPWi", "4", "AArch64::LDRDui", "AArch64::LDURDi", "AArch64::LDRXui", "AArch64::LDURXi", "AArch64::STRDui", "AArch64::STURDi", "AArch64::STRXui", "AArch64::STURXi", "AArch64::LDPDi", "AArch64::LDPXi", "AArch64::STPDi", "AArch64::STPXi", "8", "AArch64::LDRQui", "AArch64::LDURQi", "AArch64::STRQui", "AArch64::STURQi", "AArch64::LDPQi", "AArch64::STPQi", "16" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown rematerializable operation!\"", ")", ";", "break", ";", "case", "PPC", "::", "LI", ":", "case", "PPC", "::", "LI8", ":", "case", "PPC", "::", "LIS", ":", "case", "PPC", "::", "LIS8", ":", "case", "PPC", "::", "QVGPCI", ":", "case", "PPC", "::", "ADDIStocHA8", ":", "case", "PPC", "::", "ADDItocL", ":", "case", "PPC", "::", "LOAD_STACK_GUARD", ":", "case", "PPC", "::", "XXLXORz", ":", "case", "PPC", "::", "XXLXORspz", ":", "case", "PPC", "::", "XXLXORdpz", ":", "case", "PPC", "::", "V_SET0B", ":", "case", "PPC", "::", "V_SET0H", ":", "case", "PPC", "::", "V_SET0", ":", "case", "PPC", "::", "V_SETALLONESB", ":", "case", "PPC", "::", "V_SETALLONESH", ":", "case", "PPC", "::", "V_SETALLONES", ":", "case", "PPC", "::", "CRSET", ":", "case", "PPC", "::", "CRUNSET", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "PowerPC", "PPC", "\"Unknown rematerializable operation!\"", "PPC::LI", "PPC::LI8", "PPC::LIS", "PPC::LIS8", "PPC::QVGPCI", "PPC::ADDIStocHA8", "PPC::ADDItocL", "PPC::LOAD_STACK_GUARD", "PPC::XXLXORz", "PPC::XXLXORspz", "PPC::XXLXORdpz", "PPC::V_SET0B", "PPC::V_SET0H", "PPC::V_SET0", "PPC::V_SETALLONESB", "PPC::V_SETALLONESH", "PPC::V_SETALLONES", "PPC::CRSET", "PPC::CRUNSET" ]

[]

[ "<s>", "SMLoc", "getLoc", "(", ")", "const", "{", "return", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "source", "location", "of", "the", "point", "where", "the", "field", "was", "defined", "." ]

[ "ARM64" ]

[]

[ "<s>", "SDValue", "PIC16TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "unsigned", "NumRet", "=", "Outs", ".", "size", "(", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "std", "::", "string", "FuncName", "=", "F", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "createESName", "(", "PAN", "::", "getFrameLabel", "(", "FuncName", ")", ")", ";", "SDValue", "ES", "=", "DAG", ".", "getTargetExternalSymbol", "(", "tmpName", ",", "MVT", "::", "i8", ")", ";", "SDValue", "BS", "=", "DAG", ".", "getConstant", "(", "1", ",", "MVT", "::", "i8", ")", ";", "SDValue", "RetVal", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumRet", ";", "++", "i", ")", "{", "RetVal", "=", "Outs", "[", "i", "]", ".", "Val", ";", "Chain", "=", "DAG", ".", "getNode", "(", "PIC16ISD", "::", "PIC16Store", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetVal", ",", "ES", ",", "BS", ",", "DAG", ".", "getConstant", "(", "i", ",", "MVT", "::", "i8", ")", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "PIC16ISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "ISD::OutputArg", "MVT::i8", "1", "MVT::i8", "0", "PIC16ISD::PIC16Store", "MVT::Other", "MVT::i8", "PIC16ISD::RET", "MVT::Other" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "MipsTargetMachine", "&", "TM", "=", "getMipsTargetMachine", "(", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", "TM", ")", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "hasStandardEncoding", "(", ")", ")", "addPass", "(", "createMipsLongBranchPass", "(", "TM", ")", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMips16Mode", "(", ")", ")", "addPass", "(", "createMipsConstantIslandPass", "(", "TM", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "addPass", "(", "createMipsNaClRewritePass", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "bool", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createSIInsertWaits", "(", "*", "TM", ")", ",", "false", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "bool", "scalar_chain", "::", "add_insn", "(", "bitmap", "candidates", ",", "unsigned", "int", "insn_uid", ",", "bitmap", "disallowed", ")", "{", "if", "(", "!", "bitmap_set_bit", "(", "insns", ",", "insn_uid", ")", ")", "return", "true", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Adding insn %d to chain #%d\\n\"", ",", "insn_uid", ",", "chain_id", ")", ";", "rtx_insn", "*", "insn", "=", "DF_INSN_UID_GET", "(", "insn_uid", ")", "->", "insn", ";", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "def_set", "&&", "REG_P", "(", "SET_DEST", "(", "def_set", ")", ")", "&&", "!", "HARD_REGISTER_P", "(", "SET_DEST", "(", "def_set", ")", ")", ")", "bitmap_set_bit", "(", "defs", ",", "REGNO", "(", "SET_DEST", "(", "def_set", ")", ")", ")", ";", "df_ref", "ref", ";", "for", "(", "ref", "=", "DF_INSN_UID_DEFS", "(", "insn_uid", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "!", "HARD_REGISTER_P", "(", "DF_REF_REG", "(", "ref", ")", ")", ")", "if", "(", "!", "analyze_register_chain", "(", "candidates", ",", "ref", ",", "disallowed", ")", ")", "return", "false", ";", "if", "(", "def_set", "&&", "GET_CODE", "(", "SET_SRC", "(", "def_set", ")", ")", "==", "VEC_SELECT", ")", "return", "true", ";", "for", "(", "ref", "=", "DF_INSN_UID_USES", "(", "insn_uid", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "!", "DF_REF_REG_MEM_P", "(", "ref", ")", ")", "if", "(", "!", "analyze_register_chain", "(", "candidates", ",", "ref", ",", "disallowed", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "instruction", "into", "a", "chain", ".", "Return", "true", "if", "OK", ",", "false", "if", "the", "search", "was", "aborted", "." ]

[ "i386", "\" Adding insn %d to chain #%d\\n\"" ]

[]

[ "<s>", "HexagonTargetObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "static_cast", "<", "HexagonTargetObjectFile", "*", ">", "(", "TLOF", ".", "get", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

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

[]

[ "<s>", "static", "void", "nvptx_assemble_value", "(", "unsigned", "HOST_WIDE_INT", "val", ",", "unsigned", "size", ")", "{", "bool", "negative_p", "=", "val", "&", "(", "HOST_WIDE_INT_1U", "<<", "(", "HOST_BITS_PER_WIDE_INT", "-", "1", ")", ")", ";", "if", "(", "size", "*", "BITS_PER_UNIT", "<", "HOST_BITS_PER_WIDE_INT", ")", "val", "&=", "(", "HOST_WIDE_INT_1U", "<<", "(", "size", "*", "BITS_PER_UNIT", ")", ")", "-", "1", ";", "for", "(", "unsigned", "part", "=", "0", ";", "size", ";", "size", "-=", "part", ")", "{", "if", "(", "part", "*", "BITS_PER_UNIT", "==", "HOST_BITS_PER_WIDE_INT", ")", "val", "=", "negative_p", "?", "-", "1", ":", "0", ";", "else", "val", ">>=", "(", "part", "*", "BITS_PER_UNIT", ")", ";", "part", "=", "init_frag", ".", "size", "-", "init_frag", ".", "offset", ";", "part", "=", "MIN", "(", "part", ",", "size", ")", ";", "unsigned", "HOST_WIDE_INT", "partial", "=", "val", "<<", "(", "init_frag", ".", "offset", "*", "BITS_PER_UNIT", ")", ";", "init_frag", ".", "val", "|=", "partial", "&", "init_frag", ".", "mask", ";", "init_frag", ".", "offset", "+=", "part", ";", "if", "(", "init_frag", ".", "offset", "==", "init_frag", ".", "size", ")", "output_init_frag", "(", "NULL", ")", ";", "}", "}", "</s>" ]

[ "Add", "value", "VAL", "sized", "SIZE", "to", "the", "data", "we", "'re", "emitting", ",", "and", "keep", "writing", "out", "chunks", "as", "they", "fill", "up", "." ]

[ "nvptx", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "aarch64_can_const_movi_rtx_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_SIMD", ")", "return", "false", ";", "machine_mode", "vmode", ";", "scalar_int_mode", "imode", ";", "unsigned", "HOST_WIDE_INT", "ival", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "!", "aarch64_reinterpret_float_as_int", "(", "x", ",", "&", "ival", ")", ")", "return", "false", ";", "if", "(", "aarch64_float_const_zero_rtx_p", "(", "x", ")", ")", "return", "true", ";", "imode", "=", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "&&", "is_a", "<", "scalar_int_mode", ">", "(", "mode", ",", "&", "imode", ")", ")", "ival", "=", "INTVAL", "(", "x", ")", ";", "else", "return", "false", ";", "int", "width", "=", "GET_MODE_BITSIZE", "(", "imode", ")", "==", "64", "?", "128", ":", "64", ";", "vmode", "=", "aarch64_simd_container_mode", "(", "imode", ",", "width", ")", ";", "rtx", "v_op", "=", "aarch64_simd_gen_const_vector_dup", "(", "vmode", ",", "ival", ")", ";", "return", "aarch64_simd_valid_immediate", "(", "v_op", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "rtx", "X", "is", "immediate", "constant", "that", "fits", "in", "a", "single", "MOVI", "immediate", "operation", "." ]

[ "aarch64", "64", "128", "64" ]

[]

[ "<s>", "static", "const", "char", "*", "elf_platform", "(", "void", ")", "{", "int", "fd", ";", "fd", "=", "open", "(", "\"/proc/self/auxv\"", ",", "O_RDONLY", ")", ";", "if", "(", "fd", "!=", "-", "1", ")", "{", "char", "buf", "[", "1024", "]", ";", "ElfW", "(", "auxv_t", ")", "*", "av", ";", "ssize_t", "n", ";", "n", "=", "read", "(", "fd", ",", "buf", ",", "sizeof", "(", "buf", ")", ")", ";", "close", "(", "fd", ")", ";", "if", "(", "n", ">", "0", ")", "{", "for", "(", "av", "=", "(", "ElfW", "(", "auxv_t", ")", "*", ")", "buf", ";", "av", "->", "a_type", "!=", "AT_NULL", ";", "++", "av", ")", "switch", "(", "av", "->", "a_type", ")", "{", "case", "AT_PLATFORM", ":", "return", "(", "const", "char", "*", ")", "av", "->", "a_un", ".", "a_val", ";", "default", ":", "break", ";", "}", "}", "}", "</s>" ]

[ "Returns", "the", "canonical", "AT_PLATFORM", "if", "present", ",", "otherwise", "NULL", "." ]

[ "rs6000", "\"/proc/self/auxv\"", "1", "1024", "0" ]

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "bool", "IsAcquire", "=", "isAcquireOrStronger", "(", "Ord", ")", ";", "if", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxp", ":", "Intrinsic", "::", "aarch64_ldxp", ";", "Function", "*", "Ldxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ",", "\"lohi\"", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxr", ":", "Intrinsic", "::", "aarch64_ldxr", ";", "Function", "*", "Ldxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateTruncOrBitCast", "(", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ")", ",", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "128", "Intrinsic::ID", "Intrinsic::aarch64_ldaxp", "Intrinsic::aarch64_ldxp", "Intrinsic::getDeclaration", "\"lohi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "64", "\"val64\"", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "Intrinsic::getDeclaration" ]

[]

[ "<s>", "WebAssemblyTargetMachine", "::", "WebAssemblyTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ".", "isArch64Bit", "(", ")", "?", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", ":", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ",", "TT", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Large", ")", ",", "OL", ")", ",", "TLOF", "(", "new", "WebAssemblyTargetObjectFile", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "FunctionSections", "=", "true", ";", "this", "->", "Options", ".", "DataSections", "=", "true", ";", "this", "->", "Options", ".", "UniqueSectionNames", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "WebAssembly", "architecture", "model", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", "WebAssembly" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "Cpu0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "bool", "UseSplitPush", "=", "STI", ".", "splitFramePushPop", "(", "*", "MF", ")", ";", "const", "MCPhysReg", "*", "RegList", "=", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_SaveList", ":", "(", "UseSplitPush", "?", "CSR_AAPCS_SplitPush_SaveList", ":", "CSR_AAPCS_SaveList", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "return", "CSR_NoRegs_SaveList", ";", "}", "else", "if", "(", "F", "->", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "isMClass", "(", ")", ")", "{", "return", "UseSplitPush", "?", "CSR_AAPCS_SplitPush_SaveList", ":", "CSR_AAPCS_SaveList", ";", "}", "else", "if", "(", "F", "->", "getFnAttribute", "(", "\"interrupt\"", ")", ".", "getValueAsString", "(", ")", "==", "\"FIQ\"", ")", "{", "return", "CSR_FIQ_SaveList", ";", "}", "else", "{", "return", "CSR_GenericInt_SaveList", ";", "}", "}", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "&&", "STI", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "F", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_iOS_SwiftError_SaveList", ";", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_iOS_CXX_TLS_PE_SaveList", ":", "CSR_iOS_CXX_TLS_SaveList", ";", "return", "RegList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "ARM", "ARM", "ARM", "ARM", "\"interrupt\"", "\"interrupt\"", "\"FIQ\"", "ARM" ]

[]

[ "<s>", "unsigned", "XCoreInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "int", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "XCore", "::", "STWFI", ")", "{", "if", "(", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "XCore", "XCore", "XCore::STWFI", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">>", "WebAssemblyInstrInfo", "::", "getSerializableTargetIndices", "(", ")", "const", "{", "static", "const", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">", "TargetIndices", "[", "]", "=", "{", "{", "WebAssembly", "::", "TI_LOCAL", ",", "\"wasm-local\"", "}", ",", "{", "WebAssembly", "::", "TI_GLOBAL_FIXED", ",", "\"wasm-global-fixed\"", "}", ",", "{", "WebAssembly", "::", "TI_OPERAND_STACK", ",", "\"wasm-operand-stack\"", "}", ",", "{", "WebAssembly", "::", "TI_GLOBAL_RELOC", ",", "\"wasm-global-reloc\"", "}", ",", "{", "WebAssembly", "::", "TI_LOCAL_INDIRECT", ",", "\"wasm-local-indirect\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetIndices", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "ids", "of", "the", "target", "indices", "(", "used", "for", "the", "TargetIndex", "machine", "operand", ")", "and", "their", "names", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::TI_LOCAL", "\"wasm-local\"", "WebAssembly::TI_GLOBAL_FIXED", "\"wasm-global-fixed\"", "WebAssembly::TI_OPERAND_STACK", "\"wasm-operand-stack\"", "WebAssembly::TI_GLOBAL_RELOC", "\"wasm-global-reloc\"", "WebAssembly::TI_LOCAL_INDIRECT", "\"wasm-local-indirect\"" ]

[]

[ "<s>", "const", "char", "*", "Tile64TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "T64ISD", "::", "MOVELO", ":", "return", "\"T64ISD::MOVELO\"", ";", "case", "T64ISD", "::", "ADDLO_PIC", ":", "return", "\"T64ISD::ADDLO_PIC\"", ";", "case", "T64ISD", "::", "ADDHI", ":", "return", "\"T64ISD::ADDHI\"", ";", "case", "T64ISD", "::", "ADDHI_PIC", ":", "return", "\"T64ISD::ADDHI_PIC\"", ";", "case", "T64ISD", "::", "ADDLI_GOT", ":", "return", "\"T64ISD::ADDLI_GOT\"", ";", "case", "T64ISD", "::", "JAL", ":", "return", "\"T64ISD::JAL\"", ";", "case", "T64ISD", "::", "JALR", ":", "return", "\"T64ISD::JALR\"", ";", "case", "T64ISD", "::", "JRP", ":", "return", "\"T64ISD::JRP\"", ";", "case", "T64ISD", "::", "CALL", ":", "return", "\"T64ISD::CALL\"", ";", "case", "T64ISD", "::", "PICCALL", ":", "return", "\"T64ISD::PICCALL\"", ";", "case", "T64ISD", "::", "PREFETCH", ":", "return", "\"T64ISD::PREFETCH\"", ";", "case", "T64ISD", "::", "FENCE", ":", "return", "\"T64ISD::FENCE\"", ";", "case", "T64ISD", "::", "MEMBARRIER", ":", "return", "\"T64ISD::MEMBARRIER\"", ";", "case", "T64ISD", "::", "MULHH_SS", ":", "return", "\"T64ISD::MULHH_SS\"", ";", "case", "T64ISD", "::", "MULHH_SU", ":", "return", "\"T64ISD::MULHH_SU\"", ";", "case", "T64ISD", "::", "MULHH_UU", ":", "return", "\"T64IDF::MULHH_UU\"", ";", "case", "T64ISD", "::", "MULHHA_SS", ":", "return", "\"T64ISD::MULHHA_SS\"", ";", "case", "T64ISD", "::", "MULHHA_SU", ":", "return", "\"T64ISD::MULHHA_SU\"", ";", "case", "T64ISD", "::", "MULHHA_UU", ":", "return", "\"T64ISD::MULHHA_UU\"", ";", "case", "T64ISD", "::", "MULHHSA_UU", ":", "return", "\"T64ISD::MULHHSA_UU\"", ";", "case", "T64ISD", "::", "MULHL_SS", ":", "return", "\"T64ISD::MULHL_SS\"", ";", "case", "T64ISD", "::", "MULHL_SU", ":", "return", "\"T64ISD::MULHL_SU\"", ";", "case", "T64ISD", "::", "MULHL_US", ":", "return", "\"T64ISD::MULHL_US\"", ";", "case", "T64ISD", "::", "MULHL_UU", ":", "return", "\"T64ISD::MULHL_UU\"", ";", "case", "T64ISD", "::", "MULHLA_SS", ":", "return", "\"T64ISD::MULHLA_SS\"", ";", "case", "T64ISD", "::", "MULHLA_SU", ":", "return", "\"T64ISD::MULHLA_SU\"", ";", "case", "T64ISD", "::", "MULHLA_US", ":", "return", "\"T64ISD::MULHLA_US\"", ";", "case", "T64ISD", "::", "MULHLA_UU", ":", "return", "\"T64ISD::MULHLA_UU\"", ";", "case", "T64ISD", "::", "MULHLSA_UU", ":", "return", "\"T64ISD::MULHLSA_UU\"", ";", "case", "T64ISD", "::", "MULLL_SS", ":", "return", "\"T64ISD::MULLL_SS\"", ";", "case", "T64ISD", "::", "MULLL_SU", ":", "return", "\"T64ISD::MULLL_SU\"", ";", "case", "T64ISD", "::", "MULLL_UU", ":", "return", "\"T64ISD::MULLL_UU\"", ";", "case", "T64ISD", "::", "MULLLA_SS", ":", "return", "\"T64ISD::MULLLA_SS\"", ";", "case", "T64ISD", "::", "MULLLA_SU", ":", "return", "\"T64ISD::MULLLA_SU\"", ";", "case", "T64ISD", "::", "MULLLA_UU", ":", "return", "\"T64ISD::MULLLA_UU\"", ";", "case", "T64ISD", "::", "MULLLSA_UU", ":", "return", "\"T64ISD::MULLLSA_UU\"", ";", "case", "T64ISD", "::", "FNOP", ":", "return", "\"T64ISD::FNOP\"", ";", "case", "T64ISD", "::", "NOP", ":", "return", "\"T64ISD::NOP\"", ";", "case", "T64ISD", "::", "BITX", ":", "return", "\"T64ISD::BITX\"", ";", "case", "T64ISD", "::", "CRC32_32", ":", "return", "\"T64ISD::CRC32_32\"", ";", "case", "T64ISD", "::", "CRC32_8", ":", "return", "\"T64ISD::CRC32_8\"", ";", "case", "T64ISD", "::", "MM", ":", "return", "\"T64ISD::MM\"", ";", "case", "T64ISD", "::", "GLOBAL_BASE_REG", ":", "return", "\"T64ISD::GLOBAL_BASE_REG\"", ";", "case", "T64ISD", "::", "STORE_FP", ":", "return", "\"T64ISD::STORE_FP\"", ";", "case", "T64ISD", "::", "NEWSLOT_ADDR", ":", "return", "\"T64ISD::NEWSLOT_ADDR\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "Tile64", "0", "T64ISD::MOVELO", "\"T64ISD::MOVELO\"", "T64ISD::ADDLO_PIC", "\"T64ISD::ADDLO_PIC\"", "T64ISD::ADDHI", "\"T64ISD::ADDHI\"", "T64ISD::ADDHI_PIC", "\"T64ISD::ADDHI_PIC\"", "T64ISD::ADDLI_GOT", "\"T64ISD::ADDLI_GOT\"", "T64ISD::JAL", "\"T64ISD::JAL\"", "T64ISD::JALR", "\"T64ISD::JALR\"", "T64ISD::JRP", "\"T64ISD::JRP\"", "T64ISD::CALL", "\"T64ISD::CALL\"", "T64ISD::PICCALL", "\"T64ISD::PICCALL\"", "T64ISD::PREFETCH", "\"T64ISD::PREFETCH\"", "T64ISD::FENCE", "\"T64ISD::FENCE\"", "T64ISD::MEMBARRIER", "\"T64ISD::MEMBARRIER\"", "T64ISD::MULHH_SS", "\"T64ISD::MULHH_SS\"", "T64ISD::MULHH_SU", "\"T64ISD::MULHH_SU\"", "T64ISD::MULHH_UU", "\"T64IDF::MULHH_UU\"", "T64ISD::MULHHA_SS", "\"T64ISD::MULHHA_SS\"", "T64ISD::MULHHA_SU", "\"T64ISD::MULHHA_SU\"", "T64ISD::MULHHA_UU", "\"T64ISD::MULHHA_UU\"", "T64ISD::MULHHSA_UU", "\"T64ISD::MULHHSA_UU\"", "T64ISD::MULHL_SS", "\"T64ISD::MULHL_SS\"", "T64ISD::MULHL_SU", "\"T64ISD::MULHL_SU\"", "T64ISD::MULHL_US", "\"T64ISD::MULHL_US\"", "T64ISD::MULHL_UU", "\"T64ISD::MULHL_UU\"", "T64ISD::MULHLA_SS", "\"T64ISD::MULHLA_SS\"", "T64ISD::MULHLA_SU", "\"T64ISD::MULHLA_SU\"", "T64ISD::MULHLA_US", "\"T64ISD::MULHLA_US\"", "T64ISD::MULHLA_UU", "\"T64ISD::MULHLA_UU\"", "T64ISD::MULHLSA_UU", "\"T64ISD::MULHLSA_UU\"", "T64ISD::MULLL_SS", "\"T64ISD::MULLL_SS\"", "T64ISD::MULLL_SU", "\"T64ISD::MULLL_SU\"", "T64ISD::MULLL_UU", "\"T64ISD::MULLL_UU\"", "T64ISD::MULLLA_SS", "\"T64ISD::MULLLA_SS\"", "T64ISD::MULLLA_SU", "\"T64ISD::MULLLA_SU\"", "T64ISD::MULLLA_UU", "\"T64ISD::MULLLA_UU\"", "T64ISD::MULLLSA_UU", "\"T64ISD::MULLLSA_UU\"", "T64ISD::FNOP", "\"T64ISD::FNOP\"", "T64ISD::NOP", "\"T64ISD::NOP\"", "T64ISD::BITX", "\"T64ISD::BITX\"", "T64ISD::CRC32_32", "\"T64ISD::CRC32_32\"", "T64ISD::CRC32_8", "\"T64ISD::CRC32_8\"", "T64ISD::MM", "\"T64ISD::MM\"", "T64ISD::GLOBAL_BASE_REG", "\"T64ISD::GLOBAL_BASE_REG\"", "T64ISD::STORE_FP", "\"T64ISD::STORE_FP\"", "T64ISD::NEWSLOT_ADDR", "\"T64ISD::NEWSLOT_ADDR\"" ]

[]

[ "<s>", "bool", "xtensa_simm8", "(", "HOST_WIDE_INT", "v", ")", "{", "return", "v", ">=", "-", "128", "&&", "v", "<=", "127", ";", "}", "</s>" ]

[ "Functions", "to", "test", "Xtensa", "immediate", "operand", "validity", "." ]

[ "xtensa", "128", "127" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Don't know how to custom lower this!\"", ")", ";", "abort", "(", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "Subtarget", "->", "isTargetDarwin", "(", ")", "?", "LowerGlobalAddressDarwin", "(", "Op", ",", "DAG", ")", ":", "LowerGlobalAddressELF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CALL", ":", "return", "LowerCALL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RET", ":", "return", "LowerRET", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "VarArgsFrameIndex", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FORMAL_ARGUMENTS", ":", "return", "LowerFORMAL_ARGUMENTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "break", ";", "case", "ISD", "::", "FRAMEADDR", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BIT_CONVERT", ":", "return", "ExpandBIT_CONVERT", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "ExpandSRx", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "ARM", "ARM", "0", "\"Don't know how to custom lower this!\"", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::CALL", "ISD::RET", "ISD::SELECT_CC", "ISD::BR_CC", "ISD::BR_JT", "ISD::VASTART", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::FCOPYSIGN", "ISD::FORMAL_ARGUMENTS", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GLOBAL_OFFSET_TABLE", "ISD::INTRINSIC_WO_CHAIN", "ISD::BIT_CONVERT", "ISD::SRL", "ISD::SRA" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "empty", "(", ")", "&&", "\"WebAssembly should not have callee-saved registers\"", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ")", ")", "return", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "InsertPt", "!=", "MBB", ".", "end", "(", ")", "&&", "WebAssembly", "::", "isArgument", "(", "InsertPt", "->", "getOpcode", "(", ")", ")", ")", "++", "InsertPt", ";", "DebugLoc", "DL", ";", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "unsigned", "SPReg", "=", "WebAssembly", "::", "SP32", ";", "if", "(", "StackSize", ")", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "const", "char", "*", "ES", "=", "\"__stack_pointer\"", ";", "auto", "*", "SPSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "ES", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "GLOBAL_GET_I32", ")", ",", "SPReg", ")", ".", "addExternalSymbol", "(", "SPSymbol", ")", ";", "bool", "HasBP", "=", "hasBP", "(", "MF", ")", ";", "if", "(", "HasBP", ")", "{", "auto", "FI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "Register", "BasePtr", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "FI", "->", "setBasePointerVreg", "(", "BasePtr", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "COPY", ")", ",", "BasePtr", ")", ".", "addReg", "(", "SPReg", ")", ";", "}", "if", "(", "StackSize", ")", "{", "Register", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "SUB_I32", ")", ",", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "SPReg", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "if", "(", "HasBP", ")", "{", "Register", "BitmaskReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "Align", "Alignment", "=", "MFI", ".", "getMaxAlign", "(", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "BitmaskReg", ")", ".", "addImm", "(", "(", "int", ")", "~", "(", "Alignment", ".", "value", "(", ")", "-", "1", ")", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "AND_I32", ")", ",", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "BitmaskReg", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "COPY", ")", ",", "WebAssembly", "::", "FP32", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ";", "}", "if", "(", "StackSize", "&&", "needsSPWriteback", "(", "MF", ")", ")", "{", "writeSPToGlobal", "(", "WebAssembly", "::", "SP32", ",", "MF", ",", "MBB", ",", "InsertPt", ",", "DL", ")", ";", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "WebAssembly", "WebAssembly", "\"WebAssembly should not have callee-saved registers\"", "WebAssembly", "WebAssembly::isArgument", "WebAssembly::SP32", "\"__stack_pointer\"", "WebAssembly::GLOBAL_GET_I32", "WebAssembly", "WebAssembly::COPY", "WebAssembly::CONST_I32", "WebAssembly::SUB_I32", "WebAssembly::SP32", "WebAssembly::CONST_I32", "1", "WebAssembly::AND_I32", "WebAssembly::SP32", "WebAssembly::SP32", "WebAssembly::COPY", "WebAssembly::FP32", "WebAssembly::SP32", "WebAssembly::SP32" ]

[]

[ "<s>", "void", "MMIXRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected non-zero SPAdj value\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", "=", "getFrameLowering", "(", "MF", ")", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "assert", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", "&&", "\"eliminateFrameIndex currently requires hasFP\"", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MMIX", "::", "ADD_I", "&&", "Offset", "<", "0", "&&", "isInt", "<", "8", ">", "(", "Offset", ")", ")", "{", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "MMIX", "::", "SUB_I", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "-", "Offset", ")", ";", "}", "else", "if", "(", "Offset", "<", "0", ")", "{", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "getRegOpForImmOpVariant", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", ")", ";", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "MMIX", "::", "GPRRegClass", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "DL", ",", "TII", "->", "get", "(", "MMIX", "::", "LDI", ")", ",", "Reg", ")", ".", "addImm", "(", "Offset", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToRegister", "(", "Reg", ",", "false", ",", "false", ",", "true", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "MMIX", "MMIX", "0", "\"Unexpected non-zero SPAdj value\"", "1", "\"eliminateFrameIndex currently requires hasFP\"", "MMIX::ADD_I", "0", "8", "MMIX::SUB_I", "1", "0", "MMIX::GPRRegClass", "MMIX::LDI", "1", "1" ]

[]

[ "<s>", "rtx", "neon_make_constant", "(", "rtx", "vals", ",", "bool", "generate", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "rtx", "target", ";", "rtx", "const_vec", "=", "NULL_RTX", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_const", "=", "0", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "vals", ")", "==", "CONST_VECTOR", ")", "const_vec", "=", "vals", ";", "else", "if", "(", "GET_CODE", "(", "vals", ")", "==", "PARALLEL", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", ")", "n_const", "++", ";", "}", "if", "(", "n_const", "==", "n_elts", ")", "const_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "const_vec", "!=", "NULL", "&&", "simd_immediate_valid_for_move", "(", "const_vec", ",", "mode", ",", "NULL", ",", "NULL", ")", ")", "return", "const_vec", ";", "else", "if", "(", "TARGET_HAVE_MVE", "&&", "VALID_MVE_PRED_MODE", "(", "mode", ")", ")", "return", "mve_bool_vec_to_const", "(", "const_vec", ")", ";", "else", "if", "(", "(", "target", "=", "neon_vdup_constant", "(", "vals", ",", "generate", ")", ")", "!=", "NULL_RTX", ")", "return", "target", ";", "else", "if", "(", "const_vec", "!=", "NULL_RTX", ")", "return", "arm_disable_literal_pool", "?", "NULL_RTX", ":", "const_vec", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "VALS", ",", "which", "is", "a", "PARALLEL", "containing", "only", "constants", "(", "for", "vec_init", ")", "or", "CONST_VECTOR", ",", "efficiently", "into", "a", "register", ".", "Returns", "an", "RTX", "to", "copy", "into", "the", "register", ",", "or", "NULL_RTX", "for", "a", "PARALLEL", "that", "can", "not", "be", "converted", "into", "a", "CONST_VECTOR", "." ]

[ "arm", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "HandleByVal", "(", "CCState", "*", "State", ",", "unsigned", "&", "Size", ",", "Align", "Alignment", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFL", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "assert", "(", "Size", "&&", "\"Byval argument's size shouldn't be 0.\"", ")", ";", "Alignment", "=", "std", "::", "min", "(", "Alignment", ",", "TFL", "->", "getStackAlign", "(", ")", ")", ";", "unsigned", "FirstReg", "=", "0", ";", "unsigned", "NumRegs", "=", "0", ";", "if", "(", "State", "->", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "Fast", ")", "{", "unsigned", "RegSizeInBytes", "=", "Subtarget", ".", "getGPRSizeInBytes", "(", ")", ";", "ArrayRef", "<", "MCPhysReg", ">", "IntArgRegs", "=", "ABI", ".", "GetByValArgRegs", "(", ")", ";", "const", "MCPhysReg", "*", "ShadowRegs", "=", "ABI", ".", "IsO32", "(", ")", "?", "IntArgRegs", ".", "data", "(", ")", ":", "Mips64DPRegs", ";", "assert", "(", "Alignment", ">=", "Align", "(", "RegSizeInBytes", ")", "&&", "\"Byval argument's alignment should be a multiple of RegSizeInBytes.\"", ")", ";", "FirstReg", "=", "State", "->", "getFirstUnallocated", "(", "IntArgRegs", ")", ";", "if", "(", "(", "Alignment", ">", "RegSizeInBytes", ")", "&&", "(", "FirstReg", "%", "2", ")", ")", "{", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "FirstReg", "]", ",", "ShadowRegs", "[", "FirstReg", "]", ")", ";", "++", "FirstReg", ";", "}", "Size", "=", "alignTo", "(", "Size", ",", "RegSizeInBytes", ")", ";", "for", "(", "unsigned", "I", "=", "FirstReg", ";", "Size", ">", "0", "&&", "(", "I", "<", "IntArgRegs", ".", "size", "(", ")", ")", ";", "Size", "-=", "RegSizeInBytes", ",", "++", "I", ",", "++", "NumRegs", ")", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "I", "]", ",", "ShadowRegs", "[", "I", "]", ")", ";", "}", "State", "->", "addInRegsParamInfo", "(", "FirstReg", ",", "FirstReg", "+", "NumRegs", ")", ";", "}", "</s>" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

[ "Mips", "Mips", "\"Byval argument's size shouldn't be 0.\"", "0", "0", "Mips", "\"Byval argument's alignment should be a multiple of RegSizeInBytes.\"", "2", "0" ]

[]

[ "<s>", "Register", "RISCVRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "RISCV", "::", "X8", ":", "RISCV", "::", "X2", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "RISCV", "RISCV", "RISCV::X8", "RISCV::X2" ]

[]

[ "<s>", "static", "void", "mips_output_args_xfer", "(", "int", "fp_code", ",", "char", "direction", ")", "{", "unsigned", "int", "gparg", ",", "fparg", ",", "f", ";", "CUMULATIVE_ARGS", "cum", ";", "gcc_assert", "(", "TARGET_OLDABI", ")", ";", "mips_init_cumulative_args", "(", "&", "cum", ",", "NULL", ")", ";", "for", "(", "f", "=", "(", "unsigned", "int", ")", "fp_code", ";", "f", "!=", "0", ";", "f", ">>=", "2", ")", "{", "machine_mode", "mode", ";", "struct", "mips_arg_info", "info", ";", "if", "(", "(", "f", "&", "3", ")", "==", "1", ")", "mode", "=", "SFmode", ";", "else", "if", "(", "(", "f", "&", "3", ")", "==", "2", ")", "mode", "=", "DFmode", ";", "else", "gcc_unreachable", "(", ")", ";", "mips_get_arg_info", "(", "&", "info", ",", "&", "cum", ",", "mode", ",", "NULL", ",", "true", ")", ";", "gparg", "=", "mips_arg_regno", "(", "&", "info", ",", "false", ")", ";", "fparg", "=", "mips_arg_regno", "(", "&", "info", ",", "true", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "mips_output_32bit_xfer", "(", "direction", ",", "gparg", ",", "fparg", ")", ";", "else", "mips_output_64bit_xfer", "(", "direction", ",", "gparg", ",", "fparg", ")", ";", "function_arg_info", "arg", "(", "mode", ",", "true", ")", ";", "mips_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "cum", ")", ",", "arg", ")", ";", "}", "}", "</s>" ]

[ "Write", "out", "code", "to", "move", "floating-point", "arguments", "into", "or", "out", "of", "general", "registers", ".", "FP_CODE", "is", "the", "code", "describing", "which", "arguments", "are", "present", "(", "see", "the", "comment", "above", "the", "definition", "of", "CUMULATIVE_ARGS", "in", "mips.h", ")", ".", "DIRECTION", "is", "as", "for", "mips_output_32bit_xfer", "." ]

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

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "getPointerTy", "(", "DL", ")", ";", "if", "(", "(", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v2i64", "||", "VT", "==", "MVT", "::", "v4i32", "||", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v16i8", ")", ")", "||", "(", "Subtarget", "->", "hasMVEFloatOps", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v2f64", "||", "VT", "==", "MVT", "::", "v4f32", "||", "VT", "==", "MVT", "::", "v8f16", ")", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "ARM", "ARM", "MVT::v2i64", "MVT::v4i32", "MVT::v8i16", "MVT::v16i8", "MVT::v2f64", "MVT::v4f32", "MVT::v8f16", "MVT::getVectorVT", "MVT::i1" ]

[]