Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "ARMAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "{", "NaClAlignAllJumpTargetsAndConstantPools", "(", "MF", ")", ";", "}", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "CreateLiveInRegister", "(", "SelectionDAG", "&", "DAG", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ",", "EVT", "VT", ")", "const", "{", "return", "CreateLiveInRegister", "(", "DAG", ",", "RC", ",", "Reg", ",", "VT", ",", "SDLoc", "(", "DAG", ".", "getEntryNode", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "that", "adds", "Reg", "to", "the", "LiveIn", "list", "of", "the", "DAG", "'s", "MachineFunction", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "StackFixup", "::", "annotate", "(", "const", "Stack", "&", "stack", ")", "{", "Stack", "curStack", "(", "stack", ")", ";", "for", "(", "auto", "&", "p", ":", "Changes", ")", "{", "curStack", "+=", "p", ".", "first", ";", "p", ".", "second", "=", "curStack", ".", "toString", "(", ")", ";", "}", "}", "</s>" ]

[ "Performs", "the", "annotation", "." ]

[ "TVM" ]

[]

[ "<s>", "int", "M68kRegisterInfo", "::", "getRegisterOrder", "(", "unsigned", "Reg", ",", "const", "TargetRegisterClass", "&", "TRC", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "TRC", ".", "getNumRegs", "(", ")", ";", "++", "i", ")", "{", "if", "(", "regsOverlap", "(", "Reg", ",", "TRC", ".", "getRegister", "(", "i", ")", ")", ")", "{", "return", "i", ";", "}", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Return", "index", "of", "a", "register", "within", "a", "register", "class", ",", "otherwise", "return", "-1", "." ]

[ "M68k", "M68k", "0", "1" ]

[]

[ "<s>", "bool", "arc_check_multi", "(", "rtx", "op", ",", "bool", "push_p", ")", "{", "HOST_WIDE_INT", "len", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "unsigned", "int", "regno", ",", "i", ",", "start", ";", "unsigned", "int", "memp", "=", "push_p", "?", "0", ":", "1", ";", "rtx", "elt", ";", "if", "(", "len", "<=", "1", ")", "return", "false", ";", "start", "=", "1", ";", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ";", "if", "(", "!", "push_p", "&&", "GET_CODE", "(", "elt", ")", "==", "RETURN", ")", "start", "=", "2", ";", "for", "(", "i", "=", "start", ",", "regno", "=", "ENTER_LEAVE_START_REG", ";", "i", "<", "len", ";", "i", "++", ",", "regno", "++", ")", "{", "rtx", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "rtx", "reg", ",", "mem", ",", "addr", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "SET", ")", "return", "false", ";", "mem", "=", "XEXP", "(", "elt", ",", "memp", ")", ";", "reg", "=", "XEXP", "(", "elt", ",", "1", "-", "memp", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "!", "MEM_P", "(", "mem", ")", ")", "return", "false", ";", "if", "(", "REGNO", "(", "reg", ")", "==", "RETURN_ADDR_REGNUM", "&&", "i", "==", "start", ")", "regno", "=", "12", ";", "else", "if", "(", "REGNO", "(", "reg", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "++", "i", ";", "else", "if", "(", "REGNO", "(", "reg", ")", "!=", "regno", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "stack_pointer_rtx", ",", "XEXP", "(", "addr", ",", "0", ")", ")", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "!", "rtx_equal_p", "(", "stack_pointer_rtx", ",", "addr", ")", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Helper", "for", "{", "push/pop", "}", "_multi_operand", ":", "check", "if", "rtx", "OP", "is", "a", "suitable", "construct", "to", "match", "either", "enter", "or", "leave", "instruction", ".", "Which", "one", "which", "is", "selected", "by", "PUSH_P", "argument", "." ]

[ "arc", "0", "0", "1", "1", "1", "0", "0", "2", "0", "1", "12", "0", "0", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "shouldInsertFencesForAtomic", "(", "const", "Instruction", "*", "I", ")", "const", "{", "return", "InsertFencesForAtomic", ";", "}", "</s>" ]

[ "Helper", "functions", "for", "atomic", "operations", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "AGCELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "TextSection", "=", "(", "MCSection", "*", ")", "Ctx", ".", "getELFSection", "(", "\"BLOCK2\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_EXECINSTR", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "}", "</s>" ]

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

[ "AGC", "AGC", "\"BLOCK2\"" ]

[]

[ "<s>", "void", "emitBytes", "(", "StringRef", "Data", ")", "override", "{", "EmitMappingSymbol", "(", "\"$d\"", ")", ";", "MCELFStreamer", "::", "emitBytes", "(", "Data", ")", ";", "}", "</s>" ]

[ "Emit", "the", "bytes", "in", "Data", "into", "the", "output", "." ]

[ "CSKY", "\"$d\"" ]

[]

[ "<s>", "CCAssignFn", "*", "ARMTargetLowering", "::", "CCAssignFnForReturn", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "isVarArg", ")", "const", "{", "return", "CCAssignFnForNode", "(", "CC", ",", "true", ",", "isVarArg", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "isTargetEHABICompatible", "(", ")", "const", "{", "return", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "EABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "EABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "Android", ")", "&&", "!", "isTargetDarwin", "(", ")", "&&", "!", "isTargetWindows", "(", ")", "&&", "!", "isTargetNaCl", "(", ")", "&&", "!", "EnableARMDwarfEH", ";", "}", "</s>" ]

[ "Tests", "whether", "the", "target", "supports", "the", "EHABI", "exception", "handling", "standard", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "SDValue", "SICTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SDNode", "*", "CallNode", ",", "const", "Type", "*", "RetTy", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "SICCC", "SICCCInfo", "(", "CallConv", ",", "ABI", ".", "IsO32", "(", ")", ",", "CCInfo", ")", ";", "SICCCInfo", ".", "analyzeCallResult", "(", "Ins", ",", "Subtarget", ".", "abiUsesSoftFloat", "(", ")", ",", "CallNode", ",", "RetTy", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "SIC", "SIC", "ISD::InputArg", "16", "SIC", "SIC", "SIC", "0", "1", "2", "ISD::BITCAST" ]

[]

[ "<s>", "bool", "WebAssemblySubtarget", "::", "enableMachineScheduler", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "inline", "tree", "def_builtin", "(", "HOST_WIDE_INT", "mask", ",", "HOST_WIDE_INT", "mask2", ",", "const", "char", "*", "name", ",", "enum", "ix86_builtin_func_type", "tcode", ",", "enum", "ix86_builtins", "code", ")", "{", "tree", "decl", "=", "NULL_TREE", ";", "if", "(", "!", "(", "mask", "&", "OPTION_MASK_ISA_64BIT", ")", "||", "TARGET_64BIT", ")", "{", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "isa", "=", "mask", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "isa2", "=", "mask2", ";", "mask", "&=", "~", "OPTION_MASK_ISA_64BIT", ";", "if", "(", "(", "mask", "&", "ix86_isa_flags", "&", "OPTION_MASK_ISA_AVX512VL", ")", "&&", "mask", "!=", "OPTION_MASK_ISA_AVX512VL", ")", "mask", "&=", "~", "OPTION_MASK_ISA_AVX512VL", ";", "if", "(", "(", "mask", "&", "ix86_isa_flags", "&", "OPTION_MASK_ISA_AVX512BW", ")", "&&", "mask", "!=", "OPTION_MASK_ISA_AVX512BW", ")", "mask", "&=", "~", "OPTION_MASK_ISA_AVX512BW", ";", "if", "(", "(", "(", "mask2", "==", "0", "||", "(", "mask2", "&", "ix86_isa_flags2", ")", "!=", "0", ")", "&&", "(", "mask", "==", "0", "||", "(", "mask", "&", "ix86_isa_flags", ")", "!=", "0", ")", ")", "||", "(", "(", "mask", "&", "OPTION_MASK_ISA_MMX", ")", "!=", "0", "&&", "TARGET_MMX_WITH_SSE", ")", "||", "(", "mask2", "==", "OPTION_MASK_ISA2_AVXVNNI", ")", "||", "(", "mask2", "==", "OPTION_MASK_ISA2_AVXIFMA", ")", "||", "(", "mask2", "==", "(", "OPTION_MASK_ISA2_AVXNECONVERT", "|", "OPTION_MASK_ISA2_AVX512BF16", ")", ")", "||", "(", "lang_hooks", ".", "builtin_function", "==", "lang_hooks", ".", "builtin_function_ext_scope", ")", ")", "{", "tree", "type", "=", "ix86_get_builtin_func_type", "(", "tcode", ")", ";", "decl", "=", "add_builtin_function", "(", "name", ",", "type", ",", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "ix86_builtins", "[", "(", "int", ")", "code", "]", "=", "decl", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "set_and_not_built_p", "=", "false", ";", "}", "else", "{", "deferred_isa_values", "|=", "mask", ";", "deferred_isa_values2", "|=", "mask2", ";", "ix86_builtins", "[", "(", "int", ")", "code", "]", "=", "NULL_TREE", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "tcode", "=", "tcode", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "name", "=", "name", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "const_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "pure_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "set_and_not_built_p", "=", "true", ";", "}", "}", "return", "decl", ";", "}", "</s>" ]

[ "Add", "a", "SPARC", "builtin", "function", "with", "NAME", ",", "ICODE", ",", "CODE", "and", "TYPE", ".", "Return", "the", "function", "decl", "or", "NULL_TREE", "if", "the", "builtin", "was", "not", "added", "." ]

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

[]

[ "<s>", "Optional", "<", "Instruction", "*", ">", "AArch64TTIImpl", "::", "instCombineIntrinsic", "(", "InstCombiner", "&", "IC", ",", "IntrinsicInst", "&", "II", ")", "const", "{", "Intrinsic", "::", "ID", "IID", "=", "II", ".", "getIntrinsicID", "(", ")", ";", "switch", "(", "IID", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_sve_convert_from_svbool", ":", "return", "instCombineConvertFromSVBool", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_dup", ":", "return", "instCombineSVEDup", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpne", ":", "case", "Intrinsic", "::", "aarch64_sve_cmpne_wide", ":", "return", "instCombineSVECmpNE", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_rdffr", ":", "return", "instCombineRDFFR", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_lasta", ":", "case", "Intrinsic", "::", "aarch64_sve_lastb", ":", "return", "instCombineSVELast", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntd", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "2", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntw", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "4", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cnth", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "8", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntb", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "16", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_ptest_any", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_first", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_last", ":", "return", "instCombineSVEPTest", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_mul", ":", "case", "Intrinsic", "::", "aarch64_sve_fmul", ":", "return", "instCombineSVEVectorMul", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_tbl", ":", "return", "instCombineSVETBL", "(", "IC", ",", "II", ")", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "their", "own", "combinations", "for", "target-specific", "intrinsics", "." ]

[ "AArch64", "AArch64", "Intrinsic::ID", "Intrinsic::aarch64_sve_convert_from_svbool", "Intrinsic::aarch64_sve_dup", "Intrinsic::aarch64_sve_cmpne", "Intrinsic::aarch64_sve_cmpne_wide", "Intrinsic::aarch64_sve_rdffr", "Intrinsic::aarch64_sve_lasta", "Intrinsic::aarch64_sve_lastb", "Intrinsic::aarch64_sve_cntd", "2", "Intrinsic::aarch64_sve_cntw", "4", "Intrinsic::aarch64_sve_cnth", "8", "Intrinsic::aarch64_sve_cntb", "16", "Intrinsic::aarch64_sve_ptest_any", "Intrinsic::aarch64_sve_ptest_first", "Intrinsic::aarch64_sve_ptest_last", "Intrinsic::aarch64_sve_mul", "Intrinsic::aarch64_sve_fmul", "Intrinsic::aarch64_sve_tbl" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createPatmosELFObjectWriter", "(", "OS", ",", "OSType", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "gimple", "*", "gimple_folder", "::", "fold_to_ptrue", "(", ")", "{", "tree", "svbool_type", "=", "TREE_TYPE", "(", "lhs", ")", ";", "tree", "bool_type", "=", "TREE_TYPE", "(", "svbool_type", ")", ";", "unsigned", "int", "element_bytes", "=", "type_suffix", "(", "0", ")", ".", "element_bytes", ";", "tree_vector_builder", "builder", "(", "svbool_type", ",", "element_bytes", ",", "1", ")", ";", "builder", ".", "quick_push", "(", "build_all_ones_cst", "(", "bool_type", ")", ")", ";", "for", "(", "unsigned", "int", "i", "=", "1", ";", "i", "<", "element_bytes", ";", "++", "i", ")", "builder", ".", "quick_push", "(", "build_zero_cst", "(", "bool_type", ")", ")", ";", "return", "gimple_build_assign", "(", "lhs", ",", "builder", ".", "build", "(", ")", ")", ";", "}", "</s>" ]

[ "Fold", "the", "call", "to", "a", "PTRUE", ",", "taking", "the", "element", "size", "from", "type", "suffix", "0", "." ]

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

[]

[ "<s>", "static", "void", "rl78_start_function", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "hwi_local", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "if", "(", "cfun", "->", "machine", "->", "framesize", "==", "0", ")", "return", ";", "fprintf", "(", "file", ",", "\"\\t; start of function\\n\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize_regs", ")", "{", "fprintf", "(", "file", ",", "\"\\t; push %d:\"", ",", "cfun", "->", "machine", "->", "framesize_regs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "cfun", "->", "machine", "->", "need_to_push", "[", "i", "]", ")", "fprintf", "(", "file", ",", "\" %s\"", ",", "word_regnames", "[", "i", "*", "2", "]", ")", ";", "fprintf", "(", "file", ",", "\"\\n\"", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "fprintf", "(", "file", ",", "\"\\t; $fp points here (r22)\\n\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize_locals", ")", "fprintf", "(", "file", ",", "\"\\t; locals: %d byte%s\\n\"", ",", "cfun", "->", "machine", "->", "framesize_locals", ",", "cfun", "->", "machine", "->", "framesize_locals", "==", "1", "?", "\"\"", ":", "\"s\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize_outgoing", ")", "fprintf", "(", "file", ",", "\"\\t; outgoing: %d byte%s\\n\"", ",", "cfun", "->", "machine", "->", "framesize_outgoing", ",", "cfun", "->", "machine", "->", "framesize_outgoing", "==", "1", "?", "\"\"", ":", "\"s\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "uses_es", ")", "fprintf", "(", "file", ",", "\"\\t; uses ES register\\n\"", ")", ";", "if", "(", "MUST_SAVE_MDUC_REGISTERS", ")", "fprintf", "(", "file", ",", "\"\\t; preserves MDUC registers\\n\"", ")", ";", "}", "</s>" ]

[ "We", "do", "n't", "use", "this", "to", "actually", "emit", "the", "function", "prologue", ".", "We", "use", "this", "to", "insert", "a", "comment", "in", "the", "asm", "file", "describing", "the", "function", "." ]

[ "rl78", "0", "\"\\t; start of function\\n\"", "\"\\t; push %d:\"", "0", "16", "\" %s\"", "2", "\"\\n\"", "\"\\t; $fp points here (r22)\\n\"", "\"\\t; locals: %d byte%s\\n\"", "1", "\"\"", "\"s\"", "\"\\t; outgoing: %d byte%s\\n\"", "1", "\"\"", "\"s\"", "\"\\t; uses ES register\\n\"", "\"\\t; preserves MDUC registers\\n\"" ]

[]

[ "<s>", "static", "rtx", "gen_movdi_x", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "offset", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_movdi", "(", "dest", ",", "src", ")", ";", "}", "</s>" ]

[ "Wrapper", "functions", "that", "discards", "the", "CONST_INT", "spill", "offset", ".", "These", "exist", "so", "that", "we", "can", "give", "gr_spill/gr_fill", "the", "offset", "they", "need", "and", "use", "a", "consistant", "function", "interface", "." ]

[ "ia64" ]

[]

[ "<s>", "bool", "aarch_pac_insn_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "x", "||", "!", "INSN_P", "(", "x", ")", ")", "return", "false", ";", "rtx", "pat", "=", "PATTERN", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "rtx", "tmp", "=", "XEXP", "(", "pat", ",", "1", ")", ";", "if", "(", "tmp", "&&", "(", "(", "GET_CODE", "(", "tmp", ")", "==", "UNSPEC", "&&", "XINT", "(", "tmp", ",", "1", ")", "==", "UNSPEC_PAC_NOP", ")", "||", "(", "GET_CODE", "(", "tmp", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "tmp", ",", "1", ")", "==", "VUNSPEC_PACBTI_NOP", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "if", "X", "(", "or", "any", "sub-rtx", "of", "X", ")", "is", "a", "PACIASP/PACIBSP", "instruction", "." ]

[ "arm", "1", "1", "1" ]

[]

[ "<s>", "static", "rtx", "get_pic_reg", "(", "void", ")", "{", "if", "(", "!", "reload_completed", "&&", "!", "reload_in_progress", ")", "abort", "(", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "pic_reg", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "df_regs_ever_live_p", "(", "LAST_ARG_REGNUM", ")", ")", "cfun", "->", "machine", "->", "pic_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "LAST_ARG_REGNUM", ")", ";", "else", "cfun", "->", "machine", "->", "pic_reg", "=", "pic_offset_table_rtx", ";", "}", "return", "cfun", "->", "machine", "->", "pic_reg", ";", "}", "</s>" ]

[ "For", "PIC", "mode", "we", "'ve", "reserved", "PIC_OFFSET_TABLE_REGNUM", ",", "which", "is", "a", "caller", "saved", "register", ".", "For", "leaf", "functions", "it", "is", "more", "efficient", "to", "use", "a", "volatile", "register", "because", "we", "wo", "n't", "need", "to", "save", "and", "restore", "the", "pic", "register", ".", "This", "routine", "is", "only", "valid", "after", "register", "allocation", "is", "completed", ",", "so", "we", "can", "pick", "an", "unused", "register", "." ]

[ "spu" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "riscv_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

[ "Allocate", "a", "chunk", "of", "memory", "for", "per-function", "machine-dependent", "data", "." ]

[ "riscv" ]

[]

[ "<s>", "BitVector", "SystemZRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "SystemZ", "::", "R11D", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R11L", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R11H", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R10Q", ")", ";", "}", "Reserved", ".", "set", "(", "SystemZ", "::", "R15D", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R15L", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R15H", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R14Q", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::R11D", "SystemZ::R11L", "SystemZ::R11H", "SystemZ::R10Q", "SystemZ::R15D", "SystemZ::R15L", "SystemZ::R15H", "SystemZ::R14Q" ]

[]

[ "<s>", "void", "Cpu0AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</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", "." ]

[ "Cpu0", "Cpu0", "7", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "is", "beneficial", "to", "convert", "a", "load", "of", "a", "constant", "to", "just", "the", "constant", "itself", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "StringRef", "SIRegisterInfo", "::", "getRegAsmName", "(", "unsigned", "Reg", ")", "const", "{", "if", "(", "Reg", ">=", "BeginReg", "&&", "Reg", "<=", "EndReg", ")", "{", "\\", "unsigned", "Index", "=", "Reg", "-", "BeginReg", ";", "\\", "assert", "(", "Index", "<", "array_lengthof", "(", "RegTable", ")", ")", ";", "\\", "return", "RegTable", "[", "Index", "]", ";", "\\", "}", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0", ",", "AMDGPU", "::", "VGPR255", ",", "VGPR32RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0", ",", "AMDGPU", "::", "SGPR103", ",", "SGPR32RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1", ",", "AMDGPU", "::", "VGPR254_VGPR255", ",", "VGPR64RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1", ",", "AMDGPU", "::", "SGPR102_SGPR103", ",", "SGPR64RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2", ",", "AMDGPU", "::", "VGPR253_VGPR254_VGPR255", ",", "VGPR96RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2_VGPR3", ",", "AMDGPU", "::", "VGPR252_VGPR253_VGPR254_VGPR255", ",", "VGPR128RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "AMDGPU", "::", "SGPR100_SGPR101_SGPR102_SGPR103", ",", "SGPR128RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7", ",", "AMDGPU", "::", "VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", ",", "VGPR256RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7_VGPR8_VGPR9_VGPR10_VGPR11_VGPR12_VGPR13_VGPR14_VGPR15", ",", "AMDGPU", "::", "VGPR240_VGPR241_VGPR242_VGPR243_VGPR244_VGPR245_VGPR246_VGPR247_VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", ",", "VGPR512RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7", ",", "AMDGPU", "::", "SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", ",", "SGPR256RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7_SGPR8_SGPR9_SGPR10_SGPR11_SGPR12_SGPR13_SGPR14_SGPR15", ",", "AMDGPU", "::", "SGPR88_SGPR89_SGPR90_SGPR91_SGPR92_SGPR93_SGPR94_SGPR95_SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", ",", "SGPR512RegNames", ")", ";", "switch", "(", "Reg", ")", "{", "case", "AMDGPU", "::", "FLAT_SCR", ":", "return", "\"flat_scratch\"", ";", "case", "AMDGPU", "::", "FLAT_SCR_LO", ":", "return", "\"flat_scratch_lo\"", ";", "case", "AMDGPU", "::", "FLAT_SCR_HI", ":", "return", "\"flat_scratch_hi\"", ";", "default", ":", "return", "TargetRegisterInfo", "::", "getRegAsmName", "(", "Reg", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "assembly", "name", "for", "Reg", "." ]

[ "AMDGPU", "SI", "AMDGPU::VGPR0", "AMDGPU::VGPR255", "AMDGPU::SGPR0", "AMDGPU::SGPR103", "AMDGPU::VGPR0_VGPR1", "AMDGPU::VGPR254_VGPR255", "AMDGPU::SGPR0_SGPR1", "AMDGPU::SGPR102_SGPR103", "AMDGPU::VGPR0_VGPR1_VGPR2", "AMDGPU::VGPR253_VGPR254_VGPR255", "AMDGPU::VGPR0_VGPR1_VGPR2_VGPR3", "AMDGPU::VGPR252_VGPR253_VGPR254_VGPR255", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3", "AMDGPU::SGPR100_SGPR101_SGPR102_SGPR103", "AMDGPU::VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7", "AMDGPU::VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", "AMDGPU::VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7_VGPR8_VGPR9_VGPR10_VGPR11_VGPR12_VGPR13_VGPR14_VGPR15", "AMDGPU::VGPR240_VGPR241_VGPR242_VGPR243_VGPR244_VGPR245_VGPR246_VGPR247_VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7", "AMDGPU::SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7_SGPR8_SGPR9_SGPR10_SGPR11_SGPR12_SGPR13_SGPR14_SGPR15", "AMDGPU::SGPR88_SGPR89_SGPR90_SGPR91_SGPR92_SGPR93_SGPR94_SGPR95_SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", "AMDGPU::FLAT_SCR", "\"flat_scratch\"", "AMDGPU::FLAT_SCR_LO", "\"flat_scratch_lo\"", "AMDGPU::FLAT_SCR_HI", "\"flat_scratch_hi\"" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "const", "CallInst", "*", "CI", ")", "const", "{", "return", "CI", "->", "isTailCall", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "loongarch_asan_shadow_offset", "(", "void", ")", "{", "return", "TARGET_64BIT", "?", "(", "HOST_WIDE_INT_1", "<<", "46", ")", ":", "0", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_ASAN_SHADOW_OFFSET", "hook", "." ]

[ "loongarch", "46", "0" ]

[]

[ "<s>", "bool", "AMDGPUAtomicOptimizer", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "{", "return", "false", ";", "}", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "DominatorTreeWrapperPass", "*", "const", "DTW", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTW", "?", "&", "DTW", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "const", "TargetPassConfig", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "HasDPP", "=", "ST", ".", "hasDPP", "(", ")", ";", "visit", "(", "F", ")", ";", "const", "bool", "Changed", "=", "!", "ToReplace", ".", "empty", "(", ")", ";", "for", "(", "ReplacementInfo", "&", "Info", ":", "ToReplace", ")", "{", "optimizeAtomic", "(", "*", "Info", ".", "I", ",", "Info", ".", "Op", ",", "Info", ".", "ValIdx", ",", "Info", ".", "ValDivergent", ")", ";", "}", "ToReplace", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "pa_hpux_asm_output_external", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ")", "{", "extern_symbol", "*", "p", "=", "VEC_safe_push", "(", "extern_symbol", ",", "gc", ",", "extern_symbols", ",", "NULL", ")", ";", "gcc_assert", "(", "file", "==", "asm_out_file", ")", ";", "p", "->", "decl", "=", "decl", ";", "p", "->", "name", "=", "name", ";", "}", "</s>" ]

[ "Mark", "DECL", "(", "name", "NAME", ")", "as", "an", "external", "reference", "(", "assembler", "output", "file", "FILE", ")", ".", "This", "saves", "the", "names", "to", "output", "at", "the", "end", "of", "the", "file", "if", "actually", "referenced", "." ]

[ "pa" ]

[]

[ "<s>", "enum", "rtx_code", "ix86_reverse_condition", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ")", "{", "return", "(", "mode", "!=", "CCFPmode", "&&", "mode", "!=", "CCFPUmode", "?", "reverse_condition", "(", "code", ")", ":", "reverse_condition_maybe_unordered", "(", "code", ")", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "REVERSE_CONDITION", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "alpha_split_const_mov", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "i0", ";", "rtx", "temp", "=", "NULL_RTX", ";", "i0", "=", "alpha_extract_integer", "(", "operands", "[", "1", "]", ")", ";", "temp", "=", "alpha_emit_set_const", "(", "operands", "[", "0", "]", ",", "mode", ",", "i0", ",", "3", ",", "false", ")", ";", "if", "(", "!", "temp", "&&", "TARGET_BUILD_CONSTANTS", ")", "temp", "=", "alpha_emit_set_long_const", "(", "operands", "[", "0", "]", ",", "i0", ")", ";", "if", "(", "temp", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "temp", ")", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "temp", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Operand", "1", "is", "known", "to", "be", "a", "constant", ",", "and", "should", "require", "more", "than", "one", "instruction", "to", "load", ".", "Emit", "that", "multi-part", "load", "." ]

[ "alpha", "1", "0", "3", "0", "0", "0" ]

[]

[ "<s>", "TargetPassConfig", "*", "J2TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "struct", "J2PassConfig", ":", "public", "TargetPassConfig", "{", "J2PassConfig", "(", "J2TargetMachine", "*", "TM", ",", "PassManagerBase", "&", "PM", ")", ":", "TargetPassConfig", "(", "*", "TM", ",", "PM", ")", "{", "}", "J2TargetMachine", "&", "getJ2TargetMachine", "(", ")", "const", "{", "return", "getTM", "<", "J2TargetMachine", ">", "(", ")", ";", "}", "bool", "addInstSelector", "(", ")", "override", "{", "addPass", "(", "new", "J2DAGToDAGISel", "(", "getJ2TargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "void", "addPreEmitPass", "(", ")", "override", "{", "addPass", "(", "createJ2DelaySlotFillerPass", "(", "getJ2TargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createJ2ConstantIslandPass", "(", ")", ")", ";", "}", "}", ";", "return", "new", "J2PassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "J2", "J2", "J2", "J2", "J2", "J2", "J2", "J2", "J2", "J2", "J2", "J2", "J2", "J2" ]

[]

[ "<s>", "static", "int", "branch_dest", "(", "rtx", "branch", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "branch", ")", ";", "rtx", "dest", "=", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "?", "SET_SRC", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ":", "SET_SRC", "(", "pat", ")", ")", ";", "int", "dest_uid", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "IF_THEN_ELSE", ")", "dest", "=", "XEXP", "(", "dest", ",", "XEXP", "(", "dest", ",", "1", ")", "==", "pc_rtx", "?", "2", ":", "1", ")", ";", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "return", "INSN_ADDRESSES", "(", "dest_uid", ")", ";", "}", "</s>" ]

[ "Return", "the", "destination", "address", "of", "BRANCH", ".", "We", "need", "to", "use", "this", "instead", "of", "get_attr_length", ",", "because", "the", "cbranch_with_nops", "pattern", "conservatively", "sets", "its", "length", "to", "6", ",", "and", "we", "still", "prefer", "to", "use", "shorter", "sequences", "." ]

[ "arc", "0", "0", "1", "2", "1", "0" ]

[]

[ "<s>", "static", "bool", "fpop_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "SET", ")", "return", "false", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_FPMOVE", ":", "case", "TYPE_FPCMOVE", ":", "case", "TYPE_FP", ":", "case", "TYPE_FPCMP", ":", "case", "TYPE_FPMUL", ":", "case", "TYPE_FPDIVS", ":", "case", "TYPE_FPSQRTS", ":", "case", "TYPE_FPDIVD", ":", "case", "TYPE_FPSQRTD", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "True", "if", "INSN", "is", "a", "floating-point", "instruction", "." ]

[ "sparc" ]

[]

[ "<s>", "void", "AVRRegisterInfo", "::", "splitReg", "(", "unsigned", "Reg", ",", "unsigned", "&", "LoReg", ",", "unsigned", "&", "HiReg", ")", "const", "{", "assert", "(", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "Reg", ")", "&&", "\"can only split 16-bit registers\"", ")", ";", "LoReg", "=", "getSubReg", "(", "Reg", ",", "AVR", "::", "sub_lo", ")", ";", "HiReg", "=", "getSubReg", "(", "Reg", ",", "AVR", "::", "sub_hi", ")", ";", "}", "</s>" ]

[ "Splits", "a", "16-bit", "DREGS", "register", "into", "the", "lo/hi", "register", "pair", "." ]

[ "AVR", "AVR", "AVR::DREGSRegClass", "\"can only split 16-bit registers\"", "AVR::sub_lo", "AVR::sub_hi" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasV4TOps", "(", "false", ")", ",", "HasV5TOps", "(", "false", ")", ",", "HasV5TEOps", "(", "false", ")", ",", "HasV6Ops", "(", "false", ")", ",", "HasV6T2Ops", "(", "false", ")", ",", "HasV7Ops", "(", "false", ")", ",", "HasVFPv2", "(", "false", ")", ",", "HasVFPv3", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "UseNEONForSinglePrecisionFP", "(", "false", ")", ",", "SlowFPVMLx", "(", "false", ")", ",", "HasVMLxForwarding", "(", "false", ")", ",", "SlowFPBrcc", "(", "false", ")", ",", "InThumbMode", "(", "false", ")", ",", "HasThumb2", "(", "false", ")", ",", "IsMClass", "(", "false", ")", ",", "NoARM", "(", "false", ")", ",", "PostRAScheduler", "(", "false", ")", ",", "IsR9Reserved", "(", "ReserveR9", ")", ",", "UseMovt", "(", "false", ")", ",", "SupportsTailCall", "(", "false", ")", ",", "HasFP16", "(", "false", ")", ",", "HasD16", "(", "false", ")", ",", "HasHardwareDivide", "(", "false", ")", ",", "HasT2ExtractPack", "(", "false", ")", ",", "HasDataBarrier", "(", "false", ")", ",", "Pref32BitThumb", "(", "false", ")", ",", "AvoidCPSRPartialUpdate", "(", "false", ")", ",", "HasMPExtension", "(", "false", ")", ",", "FPOnlySP", "(", "false", ")", ",", "AllowsUnalignedMem", "(", "false", ")", ",", "Thumb2DSP", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TargetABI", "(", "ARM_ABI_APCS", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "std", "::", "string", "ArchFS", "=", "ARM_MC", "::", "ParseARMTriple", "(", "TT", ")", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "ArchFS", ".", "empty", "(", ")", ")", "ArchFS", "=", "ArchFS", "+", "\",\"", "+", "FS", ";", "else", "ArchFS", "=", "FS", ";", "}", "ParseSubtargetFeatures", "(", "CPUString", ",", "ArchFS", ")", ";", "if", "(", "!", "HasV6T2Ops", "&&", "hasThumb2", "(", ")", ")", "HasV4TOps", "=", "HasV5TOps", "=", "HasV5TEOps", "=", "HasV6Ops", "=", "HasV6T2Ops", "=", "true", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUString", ")", ";", "computeIssueWidth", "(", ")", ";", "if", "(", "TT", ".", "find", "(", "\"eabi\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "TargetABI", "=", "ARM_ABI_AAPCS", ";", "if", "(", "isAAPCS_ABI", "(", ")", ")", "stackAlignment", "=", "8", ";", "if", "(", "!", "isTargetDarwin", "(", ")", ")", "UseMovt", "=", "hasV6T2Ops", "(", ")", ";", "else", "{", "IsR9Reserved", "=", "ReserveR9", "|", "!", "HasV6Ops", ";", "UseMovt", "=", "DarwinUseMOVT", "&&", "hasV6T2Ops", "(", ")", ";", "const", "Triple", "&", "T", "=", "getTargetTriple", "(", ")", ";", "SupportsTailCall", "=", "T", ".", "getOS", "(", ")", "==", "Triple", "::", "IOS", "&&", "!", "T", ".", "isOSVersionLT", "(", "5", ",", "0", ")", ";", "}", "if", "(", "!", "isThumb", "(", ")", "||", "hasThumb2", "(", ")", ")", "PostRAScheduler", "=", "true", ";", "if", "(", "!", "StrictAlign", "&&", "hasV6Ops", "(", ")", "&&", "isTargetDarwin", "(", ")", ")", "AllowsUnalignedMem", "=", "true", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "4", "ARM", "\"generic\"", "ARM", "ARM", "\",\"", "\"eabi\"", "ARM", "8", "5", "0" ]

[]

[ "<s>", "static", "int", "sparc_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "int", "slotno", ",", "regno", ",", "padding", ";", "slotno", "=", "function_arg_slotno", "(", "get_cumulative_args", "(", "cum", ")", ",", "mode", ",", "type", ",", "named", ",", "false", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "return", "0", ";", "if", "(", "TARGET_ARCH32", ")", "{", "if", "(", "(", "slotno", "+", "(", "mode", "==", "BLKmode", "?", "CEIL_NWORDS", "(", "int_size_in_bytes", "(", "type", ")", ")", ":", "CEIL_NWORDS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", ">", "SPARC_INT_ARG_MAX", ")", "return", "(", "SPARC_INT_ARG_MAX", "-", "slotno", ")", "*", "UNITS_PER_WORD", ";", "}", "else", "{", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "(", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", "||", "slotno", "==", "SPARC_FP_ARG_MAX", "-", "1", ")", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "!", "(", "TARGET_FPU", "&&", "named", ")", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "{", "if", "(", "(", "slotno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "UNITS_PER_WORD", ")", ">", "SPARC_FP_ARG_MAX", ")", "return", "UNITS_PER_WORD", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "For", "an", "arg", "passed", "partly", "in", "registers", "and", "partly", "in", "memory", ",", "this", "is", "the", "number", "of", "bytes", "of", "registers", "used", ".", "For", "args", "passed", "entirely", "in", "registers", "or", "entirely", "in", "memory", ",", "zero", ".", "Any", "arg", "that", "starts", "in", "the", "first", "6", "regs", "but", "wo", "n't", "entirely", "fit", "in", "them", "needs", "partial", "registers", "on", "v8", ".", "On", "v9", ",", "structures", "with", "integer", "values", "in", "arg", "slots", "5,6", "will", "be", "passed", "in", "%", "o5", "and", "SP+176", ",", "and", "complex", "fp", "values", "that", "begin", "in", "the", "last", "fp", "reg", "[", "where", "``", "last", "fp", "reg", "''", "varies", "with", "the", "mode", "]", "will", "be", "split", "between", "that", "reg", "and", "memory", "." ]

[ "sparc", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "const", "char", "*", "pru_output_signed_cbranch_ubyteop2", "(", "rtx", "*", "operands", ",", "bool", "is_near", ")", "{", "static", "char", "buf", "[", "1024", "]", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "int", "regop_sign_bit_pos", "=", "sign_bit_position", "(", "operands", "[", "1", "]", ")", ";", "const", "char", "*", "cmp_opstr", ";", "const", "char", "*", "rcmp_opstr", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "switch", "(", "code", ")", "{", "case", "LT", ":", "cmp_opstr", "=", "\"qblt\"", ";", "rcmp_opstr", "=", "\"qbge\"", ";", "break", ";", "case", "LE", ":", "cmp_opstr", "=", "\"qble\"", ";", "rcmp_opstr", "=", "\"qbgt\"", ";", "break", ";", "case", "GT", ":", "cmp_opstr", "=", "\"qbgt\"", ";", "rcmp_opstr", "=", "\"qble\"", ";", "break", ";", "case", "GE", ":", "cmp_opstr", "=", "\"qbge\"", ";", "rcmp_opstr", "=", "\"qblt\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "code", "==", "LT", "||", "code", "==", "LE", ")", "{", "if", "(", "is_near", ")", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\"qbbs\\t.+8, %%1, %d\\n\\t\"", "\"%s\\t%%l3, %%1, %%u2\"", ",", "regop_sign_bit_pos", ",", "cmp_opstr", ")", ";", "else", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\"qbbs\\t.+12, %%1, %d\\n\\t\"", "\"%s\\t.+8, %%1, %%u2\\n\\t\"", "\"jmp\\t%%%%label(%%l3)\"", ",", "regop_sign_bit_pos", ",", "rcmp_opstr", ")", ";", "}", "else", "if", "(", "code", "==", "GT", "||", "code", "==", "GE", ")", "{", "if", "(", "is_near", ")", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\"qbbs\\t%%l3, %%1, %d\\n\\t\"", "\"%s\\t%%l3, %%1, %%u2\"", ",", "regop_sign_bit_pos", ",", "cmp_opstr", ")", ";", "else", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\"qbbs\\t.+8, %%1, %d\\n\\t\"", "\"%s\\t.+8, %%1, %%u2\\n\\t\"", "\"jmp\\t%%%%label(%%l3)\"", ",", "regop_sign_bit_pos", ",", "rcmp_opstr", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "buf", ";", "}", "</s>" ]

[ "Optimized", "version", "of", "pru_output_signed_cbranch", "for", "constant", "second", "operand", "." ]

[ "pru", "1024", "0", "1", "\"qblt\"", "\"qbge\"", "\"qble\"", "\"qbgt\"", "\"qbgt\"", "\"qble\"", "\"qbge\"", "\"qblt\"", "\"qbbs\\t.+8, %%1, %d\\n\\t\"", "\"%s\\t%%l3, %%1, %%u2\"", "\"qbbs\\t.+12, %%1, %d\\n\\t\"", "\"%s\\t.+8, %%1, %%u2\\n\\t\"", "\"jmp\\t%%%%label(%%l3)\"", "\"qbbs\\t%%l3, %%1, %d\\n\\t\"", "\"%s\\t%%l3, %%1, %%u2\"", "\"qbbs\\t.+8, %%1, %d\\n\\t\"", "\"%s\\t.+8, %%1, %%u2\\n\\t\"", "\"jmp\\t%%%%label(%%l3)\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARMTargetLowering", "::", "getRegClassFor", "(", "MVT", "VT", ",", "bool", "isDivergent", ")", "const", "{", "(", "void", ")", "isDivergent", ";", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", ")", "{", "if", "(", "VT", "==", "MVT", "::", "v4i64", ")", "return", "&", "ARM", "::", "QQPRRegClass", ";", "if", "(", "VT", "==", "MVT", "::", "v8i64", ")", "return", "&", "ARM", "::", "QQQQPRRegClass", ";", "}", "return", "TargetLowering", "::", "getRegClassFor", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "that", "should", "be", "used", "for", "the", "specified", "value", "type", "." ]

[ "ARM", "ARM", "MVT::v4i64", "ARM::QQPRRegClass", "MVT::v8i64", "ARM::QQQQPRRegClass" ]

[]

[ "<s>", "static", "rtx", "riscv_frame_set", "(", "rtx", "mem", ",", "rtx", "reg", ")", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "return", "set", ";", "}", "</s>" ]

[ "Return", "a", "frame-related", "rtx", "that", "stores", "REG", "at", "MEM", ".", "REG", "must", "be", "a", "single", "register", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "shouldSinkOperands", "(", "Instruction", "*", "I", ",", "SmallVectorImpl", "<", "Use", "*", ">", "&", "Ops", ")", "const", "{", "if", "(", "!", "I", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Add", ":", "{", "if", "(", "!", "areExtractExts", "(", "I", "->", "getOperand", "(", "0", ")", ",", "I", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "1", ")", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "if", "(", "!", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "auto", "IsSinker", "=", "[", "]", "(", "Instruction", "*", "I", ",", "int", "Operand", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Mul", ":", "return", "true", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "return", "Operand", "==", "1", ";", "default", ":", "return", "false", ";", "}", "}", ";", "int", "Op", "=", "0", ";", "if", "(", "!", "isa", "<", "ShuffleVectorInst", ">", "(", "I", "->", "getOperand", "(", "Op", ")", ")", ")", "Op", "=", "1", ";", "if", "(", "!", "IsSinker", "(", "I", ",", "Op", ")", ")", "return", "false", ";", "if", "(", "!", "match", "(", "I", "->", "getOperand", "(", "Op", ")", ",", "m_ShuffleVector", "(", "m_InsertElement", "(", "m_Undef", "(", ")", ",", "m_Value", "(", ")", ",", "m_ZeroInt", "(", ")", ")", ",", "m_Undef", "(", ")", ",", "m_Zero", "(", ")", ")", ")", ")", "{", "return", "false", ";", "}", "Instruction", "*", "Shuffle", "=", "cast", "<", "Instruction", ">", "(", "I", "->", "getOperand", "(", "Op", ")", ")", ";", "for", "(", "Use", "&", "U", ":", "Shuffle", "->", "uses", "(", ")", ")", "{", "Instruction", "*", "Insn", "=", "cast", "<", "Instruction", ">", "(", "U", ".", "getUser", "(", ")", ")", ";", "if", "(", "!", "IsSinker", "(", "Insn", ",", "U", ".", "getOperandNo", "(", ")", ")", ")", "return", "false", ";", "}", "Ops", ".", "push_back", "(", "&", "Shuffle", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "Op", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "sinking", "I", "'s", "operands", "to", "the", "same", "basic", "block", "as", "I", "is", "profitable", ",", "e.g", "." ]

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

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasAVX", "(", ")", "||", "ST", ".", "hasAVX512", "(", ")", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "EverMadeChange", "=", "false", ";", "bool", "FnHasLiveInYmm", "=", "checkFnHasLiveInYmm", "(", "MRI", ")", ";", "bool", "YMMUsed", "=", "FnHasLiveInYmm", ";", "if", "(", "!", "YMMUsed", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "&", "X86", "::", "VR256RegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "i", "=", "RC", "->", "begin", "(", ")", ",", "e", "=", "RC", "->", "end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "!", "MRI", ".", "reg_nodbg_empty", "(", "*", "i", ")", ")", "{", "YMMUsed", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "!", "YMMUsed", ")", "{", "return", "false", ";", "}", "assert", "(", "BlockStates", ".", "empty", "(", ")", "&&", "DirtySuccessors", ".", "empty", "(", ")", "&&", "\"X86VZeroUpper state should be clear\"", ")", ";", "BlockStates", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MBB", ")", ";", "if", "(", "FnHasLiveInYmm", ")", "addDirtySuccessor", "(", "MF", ".", "front", "(", ")", ")", ";", "while", "(", "!", "DirtySuccessors", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "DirtySuccessors", ".", "back", "(", ")", ";", "DirtySuccessors", ".", "pop_back", "(", ")", ";", "BlockState", "&", "BBState", "=", "BlockStates", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "if", "(", "BBState", ".", "FirstUnguardedCall", "!=", "MBB", ".", "end", "(", ")", ")", "insertVZeroUpper", "(", "BBState", ".", "FirstUnguardedCall", ",", "MBB", ")", ";", "if", "(", "BBState", ".", "ExitState", "==", "PASS_THROUGH", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB #\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\" was Pass-through, is now Dirty-out.\\n\"", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "SI", "=", "MBB", ".", "succ_begin", "(", ")", ",", "SE", "=", "MBB", ".", "succ_end", "(", ")", ";", "SI", "!=", "SE", ";", "++", "SI", ")", "addDirtySuccessor", "(", "*", "*", "SI", ")", ";", "}", "}", "BlockStates", ".", "clear", "(", ")", ";", "return", "EverMadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::VR256RegClass", "\"X86VZeroUpper state should be clear\"", "\"MBB #\"", "\" was Pass-through, is now Dirty-out.\\n\"" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "SrcReg", ")", "&&", "\"Only GPR32 src copy supported.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "DestReg", ")", "&&", "\"Only GPR32 dest copy supported.\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "MOV_rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "ARC", "ARC", "ARC::GPR32RegClass", "\"Only GPR32 src copy supported.\"", "ARC::GPR32RegClass", "\"Only GPR32 dest copy supported.\"", "ARC::MOV_rr" ]

[]

[ "<s>", "static", "rtx", "neon_vdup_constant", "(", "rtx", "vals", ",", "bool", "generate", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "x", ";", "if", "(", "GET_CODE", "(", "vals", ")", "!=", "CONST_VECTOR", "||", "GET_MODE_SIZE", "(", "inner_mode", ")", ">", "4", ")", "return", "NULL_RTX", ";", "if", "(", "!", "const_vec_duplicate_p", "(", "vals", ",", "&", "x", ")", ")", "return", "NULL_RTX", ";", "if", "(", "!", "generate", ")", "return", "x", ";", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "x", ")", ";", "return", "gen_vec_duplicate", "(", "mode", ",", "x", ")", ";", "}", "</s>" ]

[ "Return", "a", "non-NULL", "RTX", "iff", "VALS", "is", "a", "vector", "constant", "that", "can", "be", "loaded", "into", "a", "register", "using", "VDUP", ".", "If", "this", "is", "the", "case", ",", "and", "GENERATE", "is", "set", ",", "we", "also", "generate", "instructions", "to", "do", "this", "and", "return", "an", "RTX", "to", "assign", "to", "the", "register", "." ]

[ "arm", "4" ]

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "bool", "isMicroMips", "=", "Subtarget", ".", "inMicroMipsMode", "(", ")", ";", "unsigned", "Opc", ";", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA", ":", "expandRetRA", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI", ":", "Opc", "=", "isMicroMips", "?", "Mips", "::", "MFHI16_MM", ":", "Mips", "::", "MFHI", ";", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Opc", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO", ":", "Opc", "=", "isMicroMips", "?", "Mips", "::", "MFLO16_MM", ":", "Mips", "::", "MFLO", ";", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Opc", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFHI64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFLO64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO", ",", "Mips", "::", "MTHI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI64", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO64", ",", "Mips", "::", "MTHI64", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI_DSP", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO_DSP", ",", "Mips", "::", "MTHI_DSP", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D32_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D32_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_W", ",", "Mips", "::", "MTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64_64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64_64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "MIPSeh_return32", ":", "case", "Mips", "::", "MIPSeh_return64", ":", "expandEhReturn", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::RetRA", "Mips::PseudoMFHI", "Mips", "Mips::MFHI16_MM", "Mips::MFHI", "Mips::PseudoMFLO", "Mips", "Mips::MFLO16_MM", "Mips::MFLO", "Mips::PseudoMFHI64", "Mips::MFHI64", "Mips::PseudoMFLO64", "Mips::MFLO64", "Mips::PseudoMTLOHI", "Mips::MTLO", "Mips::MTHI", "Mips::PseudoMTLOHI64", "Mips::MTLO64", "Mips::MTHI64", "Mips::PseudoMTLOHI_DSP", "Mips::MTLO_DSP", "Mips::MTHI_DSP", "Mips::PseudoCVT_S_W", "Mips::CVT_S_W", "Mips::MTC1", "Mips::PseudoCVT_D32_W", "Mips::CVT_D32_W", "Mips::MTC1", "Mips::PseudoCVT_S_L", "Mips::CVT_S_L", "Mips::DMTC1", "Mips::PseudoCVT_D64_W", "Mips::CVT_D64_W", "Mips::MTC1", "Mips::PseudoCVT_D64_L", "Mips::CVT_D64_L", "Mips::DMTC1", "Mips::BuildPairF64", "Mips::BuildPairF64_64", "Mips::ExtractElementF64", "Mips::ExtractElementF64_64", "Mips::MIPSeh_return32", "Mips::MIPSeh_return64" ]

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getScalarizationOverhead", "(", "VectorType", "*", "Ty", ",", "const", "APInt", "&", "DemandedElts", ",", "bool", "Insert", ",", "bool", "Extract", ")", "{", "return", "BaseT", "::", "getScalarizationOverhead", "(", "Ty", ",", "DemandedElts", ",", "Insert", ",", "Extract", ")", ";", "}", "</s>" ]

[ "Estimate", "the", "overhead", "of", "scalarizing", "an", "instruction", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "Imm", "==", "(", "int32_t", ")", "Imm", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "icmp", "immediate", ",", "that", "is", "the", "target", "has", "icmp", "instructions", "which", "can", "compare", "a", "register", "against", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "aarch64_sve_float_mul_immediate_p", "(", "rtx", "x", ")", "{", "rtx", "elt", ";", "return", "(", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "&&", "GET_CODE", "(", "elt", ")", "==", "CONST_DOUBLE", "&&", "(", "real_equal", "(", "CONST_DOUBLE_REAL_VALUE", "(", "elt", ")", ",", "&", "dconsthalf", ")", "||", "real_equal", "(", "CONST_DOUBLE_REAL_VALUE", "(", "elt", ")", ",", "&", "dconst2", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "operand", "for", "an", "SVE", "FMUL", "instruction", "." ]

[ "aarch64" ]

[]

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

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

[ "SNES", "SNES" ]

[]

[ "<s>", "static", "bool", "arm_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "HFmode", ")", "return", "(", "arm_fp16_format", "!=", "ARM_FP16_FORMAT_NONE", ")", ";", "else", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", ".", "This", "simply", "adds", "HFmode", "as", "a", "supported", "mode", ";", "even", "though", "we", "do", "n't", "implement", "arithmetic", "on", "this", "type", "directly", ",", "it", "'s", "supported", "by", "optabs", "conversions", ",", "much", "the", "way", "the", "double-word", "arithmetic", "is", "special-cased", "in", "the", "default", "hook", "." ]

[ "arm" ]

[]

[ "<s>", "static", "sbitmap", "aarch64_components_for_bb", "(", "basic_block", "bb", ")", "{", "bitmap", "in", "=", "DF_LIVE_IN", "(", "bb", ")", ";", "bitmap", "gen", "=", "&", "DF_LIVE_BB_INFO", "(", "bb", ")", "->", "gen", ";", "bitmap", "kill", "=", "&", "DF_LIVE_BB_INFO", "(", "bb", ")", "->", "kill", ";", "bool", "simd_function", "=", "aarch64_simd_decl_p", "(", "cfun", "->", "decl", ")", ";", "sbitmap", "components", "=", "sbitmap_alloc", "(", "LAST_SAVED_REGNUM", "+", "1", ")", ";", "bitmap_clear", "(", "components", ")", ";", "for", "(", "unsigned", "regno", "=", "0", ";", "regno", "<=", "LAST_SAVED_REGNUM", ";", "regno", "++", ")", "if", "(", "(", "!", "call_used_regs", "[", "regno", "]", "||", "(", "simd_function", "&&", "FP_SIMD_SAVED_REGNUM_P", "(", "regno", ")", ")", ")", "&&", "(", "bitmap_bit_p", "(", "in", ",", "regno", ")", "||", "bitmap_bit_p", "(", "gen", ",", "regno", ")", "||", "bitmap_bit_p", "(", "kill", ",", "regno", ")", ")", ")", "{", "unsigned", "regno2", ",", "offset", ",", "offset2", ";", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "regno2", "=", "(", "(", "offset", "&", "8", ")", "==", "0", ")", "?", "regno", "+", "1", ":", "regno", "-", "1", ";", "if", "(", "regno2", "<=", "LAST_SAVED_REGNUM", ")", "{", "offset2", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "if", "(", "(", "offset", "&", "~", "8", ")", "==", "(", "offset2", "&", "~", "8", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno2", ")", ";", "}", "}", "return", "components", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB", "." ]

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

[]

[ "<s>", "bool", "XtensaPassConfig", "::", "addInstSelector", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "MipsSubtarget", "::", "enablePostRAScheduler", "(", "CodeGenOpt", "::", "Level", "OptLevel", ",", "TargetSubtargetInfo", "::", "AntiDepBreakMode", "&", "Mode", ",", "RegClassVector", "&", "CriticalPathRCs", ")", "const", "{", "Mode", "=", "TargetSubtargetInfo", "::", "ANTIDEP_NONE", ";", "CriticalPathRCs", ".", "clear", "(", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "hasMips64", "(", ")", "?", "&", "Mips", "::", "CPU64RegsRegClass", ":", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "return", "OptLevel", ">=", "CodeGenOpt", "::", "Aggressive", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips", "Mips::CPU64RegsRegClass", "Mips::CPURegsRegClass" ]

[]

[ "<s>", "StackOffset", "M88kFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "return", "StackOffset", "::", "getFixed", "(", "resolveFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k" ]

[]

[ "<s>", "void", "PPCDispatchGroupSBHazardRecognizer", "::", "EmitNoop", "(", ")", "{", "unsigned", "Directive", "=", "DAG", "->", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR6", "||", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "CurSlots", "==", "6", ")", "{", "CurGroup", ".", "clear", "(", ")", ";", "CurSlots", "=", "CurBranches", "=", "0", ";", "}", "else", "{", "CurGroup", ".", "push_back", "(", "0", ")", ";", "++", "CurSlots", ";", "}", "}", "</s>" ]

[ "EmitNoop", "-", "This", "callback", "is", "invoked", "when", "a", "noop", "was", "added", "to", "the", "instruction", "stream", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_PWR6", "PPC::DIR_PWR7", "6", "0", "0" ]

[]

[ "<s>", "void", "Z80InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "Z80", "::", "GR8RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Z80", "::", "LD8rxm", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "Z80", "::", "BR16RegClass", "||", "Z80", "::", "BR16RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Z80", "::", "LD16rxm", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "Z80", "::", "GR16RegClass", "||", "Z80", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Z80", "::", "LD16rxm", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "Z80", "Z80", "Z80::GR8RegClass", "Z80::LD8rxm", "0", "Z80::BR16RegClass", "Z80::BR16RegClass", "Z80::LD16rxm", "0", "Z80::GR16RegClass", "Z80::GR16RegClass", "Z80::LD16rxm", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "RC", "==", "&", "Hexagon", "::", "IntRegsRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadri_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "Hexagon", "::", "DoubleRegsRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadrd_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "Hexagon", "::", "PredRegsRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_pred", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::L2_loadri_io", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::L2_loadrd_io", "0", "Hexagon::PredRegsRegClass", "Hexagon::LDriw_pred", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "static", "int", "ix86_nsaved_regs", "(", "void", ")", "{", "int", "nregs", "=", "0", ";", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ")", ")", "nregs", "++", ";", "return", "nregs", ";", "}", "</s>" ]

[ "Return", "number", "of", "registers", "to", "be", "saved", "on", "the", "stack", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"AZPR Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "AZPR", "\"AZPR Delay Slot Filler\"" ]

[]

[ "<s>", "void", "AArch64TargetELFStreamer", "::", "emitDirectiveVariantPCS", "(", "MCSymbol", "*", "Symbol", ")", "{", "cast", "<", "MCSymbolELF", ">", "(", "Symbol", ")", "->", "setOther", "(", "ELF", "::", "STO_AARCH64_VARIANT_PCS", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".variant_pcs", "directive", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "const", "GlobalValue", "*", "GV", "=", "GA", "->", "getGlobal", "(", ")", ";", "return", "isa", "<", "Function", ">", "(", "GV", ")", "?", "false", ":", "TargetLowering", "::", "isOffsetFoldingLegal", "(", "GA", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "GCNUpwardRPTracker", "::", "reset", "(", "const", "MachineInstr", "&", "MI", ")", "{", "MRI", "=", "&", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "LiveRegs", "=", "getLiveRegsAfter", "(", "MI", ",", "LIS", ")", ";", "MaxPressure", "=", "CurPressure", "=", "getRegPressure", "(", "*", "MRI", ",", "LiveRegs", ")", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "tree", "arm_handle_cmse_nonsecure_entry", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "fndecl", ";", "if", "(", "!", "use_cmse", ")", "{", "*", "no_add_attrs", "=", "true", ";", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute ignored without -mcmse option.\"", ",", "name", ")", ";", "return", "NULL_TREE", ";", "}", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "}", "fndecl", "=", "*", "node", ";", "if", "(", "!", "TREE_PUBLIC", "(", "fndecl", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute has no effect on functions \"", "\"with static linkage\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "}", "*", "no_add_attrs", "|=", "cmse_func_args_or_return_in_stack", "(", "fndecl", ",", "name", ",", "TREE_TYPE", "(", "fndecl", ")", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Called", "upon", "detection", "of", "the", "use", "of", "the", "cmse_nonsecure_entry", "attribute", ",", "this", "function", "will", "check", "whether", "the", "attribute", "is", "allowed", "here", "and", "will", "add", "the", "attribute", "to", "the", "function", "declaration", "tree", "or", "otherwise", "issue", "a", "warning", "." ]

[ "arm", "\"%qE attribute ignored without -mcmse option.\"", "\"%qE attribute only applies to functions\"", "\"%qE attribute has no effect on functions \"", "\"with static linkage\"" ]

[]

[ "<s>", "bool", "MLxExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Fn", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "const", "ARMSubtarget", "*", "STI", "=", "&", "Fn", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "isLikeA9", "=", "STI", "->", "isLikeA9", "(", ")", "||", "STI", "->", "isSwift", "(", ")", ";", "isSwift", "=", "STI", "->", "isSwift", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "ExpandFPMLxInstructions", "(", "MBB", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Packetizer\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Packetizer\"" ]

[]

[ "<s>", "virtual", "void", "AdvanceCycle", "(", ")", "{", "ResourceAssignment", "::", "AdvanceCycle", "(", ")", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "TMS320C64X" ]

[]

[ "<s>", "bool", "P2AsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"match and emit instruction\\n\"", ")", ";", "printP2Operands", "(", "Operands", ")", ";", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Inst", ".", "setFlags", "(", "Inst", ".", "getFlags", "(", ")", "|", "P2", "::", "ALWAYS", ")", ";", "LLVM_DEBUG", "(", "Inst", ".", "dump", "(", ")", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "P2Operand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "P2", "P2", "\"match and emit instruction\\n\"", "P2", "P2::ALWAYS", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "P2", "\"invalid operand for instruction\"", "\"invalid instruction\"" ]

[]

[ "<s>", "static", "void", "nvptx_split_blocks", "(", "bb_insn_map_t", "*", "map", ")", "{", "insn_bb_vec_t", "worklist", ";", "basic_block", "block", ";", "rtx_insn", "*", "insn", ";", "FOR_ALL_BB_FN", "(", "block", ",", "cfun", ")", "{", "bool", "seen_insn", "=", "false", ";", "block", "->", "flags", "&=", "~", "BB_VISITED", ";", "FOR_BB_INSNS", "(", "block", ",", "insn", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "default", ":", "seen_insn", "=", "true", ";", "continue", ";", "case", "CODE_FOR_nvptx_forked", ":", "case", "CODE_FOR_nvptx_join", ":", "break", ";", "case", "CODE_FOR_return", ":", "break", ";", "}", "if", "(", "seen_insn", ")", "worklist", ".", "safe_push", "(", "insn_bb_t", "(", "insn", ",", "block", ")", ")", ";", "else", "map", "->", "get_or_insert", "(", "block", ")", "=", "insn", ";", "seen_insn", "=", "true", ";", "}", "}", "unsigned", "ix", ";", "insn_bb_t", "*", "elt", ";", "basic_block", "remap", "=", "0", ";", "for", "(", "ix", "=", "0", ";", "worklist", ".", "iterate", "(", "ix", ",", "&", "elt", ")", ";", "ix", "++", ")", "{", "if", "(", "remap", "!=", "elt", "->", "second", ")", "{", "block", "=", "elt", "->", "second", ";", "remap", "=", "block", ";", "}", "edge", "e", "=", "split_block", "(", "block", ",", "PREV_INSN", "(", "elt", "->", "first", ")", ")", ";", "block", "=", "e", "->", "dest", ";", "map", "->", "get_or_insert", "(", "block", ")", "=", "elt", "->", "first", ";", "}", "}", "</s>" ]

[ "See", "also", "'gcc/omp-oacc-neuter-broadcast.cc", ":", "omp_sese_split_blocks", "'", "." ]

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

[]

[ "<s>", "static", "void", "tilegx_init_libfuncs", "(", "void", ")", "{", "set_optab_libfunc", "(", "sdiv_optab", ",", "SImode", ",", "\"__divsi3\"", ")", ";", "set_optab_libfunc", "(", "udiv_optab", ",", "SImode", ",", "\"__udivsi3\"", ")", ";", "set_optab_libfunc", "(", "smod_optab", ",", "SImode", ",", "\"__modsi3\"", ")", ";", "set_optab_libfunc", "(", "umod_optab", ",", "SImode", ",", "\"__umodsi3\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_INIT_LIBFUNCS", "." ]

[ "tilegx", "\"__divsi3\"", "\"__udivsi3\"", "\"__modsi3\"", "\"__umodsi3\"" ]

[]

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

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

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

[]

[ "<s>", "static", "const", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ")", "{", "Triple", "TheTriple", "(", "TT", ")", ";", "switch", "(", "TheTriple", ".", "getOS", "(", ")", ")", "{", "case", "Triple", "::", "Darwin", ":", "return", "new", "X86MCAsmInfoDarwin", "(", "TheTriple", ")", ";", "case", "Triple", "::", "MinGW32", ":", "case", "Triple", "::", "MinGW64", ":", "case", "Triple", "::", "Cygwin", ":", "case", "Triple", "::", "Win32", ":", "return", "new", "X86MCAsmInfoCOFF", "(", "TheTriple", ")", ";", "default", ":", "return", "new", "X86ELFMCAsmInfo", "(", "TheTriple", ")", ";", "}", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

[ "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "bool", "rs6000_vector_mode_supported_p", "(", "enum", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "return", "true", ";", "else", "if", "(", "TARGET_ALTIVEC", "&&", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Target", "hook", "for", "vector_mode_supported_p", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "alpha_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "alpha_hard_regno_mode_ok", "(", "32", ",", "mode1", ")", "?", "alpha_hard_regno_mode_ok", "(", "32", ",", "mode2", ")", ":", "true", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", ".", "This", "asymmetric", "test", "is", "true", "when", "MODE1", "could", "be", "put", "in", "an", "FP", "register", "but", "MODE2", "could", "not", "." ]

[ "alpha", "32", "32" ]

[]

[ "<s>", "int", "function_arg_boundary", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "return", "64", ";", "else", "if", "(", "SPE_VECTOR_MODE", "(", "mode", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "8", "&&", "int_size_in_bytes", "(", "type", ")", "<", "16", ")", ")", "return", "64", ";", "else", "if", "(", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "16", ")", ")", "return", "128", ";", "else", "if", "(", "rs6000_darwin64_abi", "&&", "mode", "==", "BLKmode", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "64", ")", "return", "128", ";", "else", "return", "PARM_BOUNDARY", ";", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "expression", "that", "gives", "the", "alignment", "boundary", ",", "in", "bits", ",", "of", "an", "argument", "with", "the", "specified", "mode", "and", "type", ".", "If", "it", "is", "not", "defined", ",", "PARM_BOUNDARY", "is", "used", "for", "all", "arguments", ".", "V.4", "wants", "long", "longs", "to", "be", "double", "word", "aligned", ".", "Doubleword", "align", "SPE", "vectors", ".", "Quadword", "align", "Altivec", "vectors", ".", "Quadword", "align", "large", "synthetic", "vector", "types", "." ]

[ "rs6000", "8", "64", "8", "16", "64", "16", "128", "64", "128" ]

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "rtx", "aarch64_simd_dup_constant", "(", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "bool", "all_same", "=", "true", ";", "rtx", "x", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "vals", ")", "!=", "CONST_VECTOR", ")", "return", "NULL_RTX", ";", "for", "(", "i", "=", "1", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "x", "=", "CONST_VECTOR_ELT", "(", "vals", ",", "i", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "x", ",", "CONST_VECTOR_ELT", "(", "vals", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "}", "if", "(", "!", "all_same", ")", "return", "NULL_RTX", ";", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "CONST_VECTOR_ELT", "(", "vals", ",", "0", ")", ")", ";", "return", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "x", ")", ";", "}", "</s>" ]

[ "If", "VALS", "is", "a", "vector", "constant", "that", "can", "be", "loaded", "into", "a", "register", "using", "DUP", ",", "generate", "instructions", "to", "do", "so", "and", "return", "an", "RTX", "to", "assign", "to", "the", "register", ".", "Otherwise", "return", "NULL_RTX", "." ]

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

[]

[ "<s>", "static", "void", "ix86_set_func_type", "(", "tree", "fndecl", ")", "{", "if", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_UNKNOWN", ")", "{", "if", "(", "lookup_attribute", "(", "\"interrupt\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ")", "{", "int", "nargs", "=", "0", ";", "for", "(", "tree", "arg", "=", "DECL_ARGUMENTS", "(", "fndecl", ")", ";", "arg", ";", "arg", "=", "TREE_CHAIN", "(", "arg", ")", ")", "nargs", "++", ";", "cfun", "->", "machine", "->", "no_caller_saved_registers", "=", "true", ";", "cfun", "->", "machine", "->", "func_type", "=", "nargs", "==", "2", "?", "TYPE_EXCEPTION", ":", "TYPE_INTERRUPT", ";", "ix86_optimize_mode_switching", "[", "X86_DIRFLAG", "]", "=", "1", ";", "if", "(", "write_symbols", "!=", "NO_DEBUG", "&&", "write_symbols", "!=", "DWARF2_DEBUG", ")", "sorry", "(", "\"Only DWARF debug format is supported for interrupt \"", "\"service routine.\"", ")", ";", "}", "else", "{", "cfun", "->", "machine", "->", "func_type", "=", "TYPE_NORMAL", ";", "if", "(", "lookup_attribute", "(", "\"no_caller_saved_registers\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ")", "cfun", "->", "machine", "->", "no_caller_saved_registers", "=", "true", ";", "}", "}", "}", "</s>" ]

[ "Set", "the", "func_type", "field", "from", "the", "function", "FNDECL", "." ]

[ "i386", "\"interrupt\"", "0", "2", "1", "\"Only DWARF debug format is supported for interrupt \"", "\"service routine.\"", "\"no_caller_saved_registers\"" ]

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "AArch64" ]

[]

[ "<s>", "scalar_chain", "::", "scalar_chain", "(", "enum", "machine_mode", "smode_", ",", "enum", "machine_mode", "vmode_", ")", "{", "smode", "=", "smode_", ";", "vmode", "=", "vmode_", ";", "chain_id", "=", "++", "max_id", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Created a new instruction chain #%d\\n\"", ",", "chain_id", ")", ";", "bitmap_obstack_initialize", "(", "NULL", ")", ";", "insns", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "defs", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "defs_conv", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "queue", "=", "NULL", ";", "}", "</s>" ]

[ "Initialize", "new", "chain", "." ]

[ "i386", "\"Created a new instruction chain #%d\\n\"" ]

[]

[ "<s>", "void", "visium_expand_int_cstore", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "0", "]", ",", "op1", "=", "operands", "[", "2", "]", ",", "op2", "=", "operands", "[", "3", "]", ",", "sltu", ";", "bool", "reverse", "=", "false", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "force_reg", "(", "mode", ",", "gen_rtx_XOR", "(", "mode", ",", "op1", ",", "op2", ")", ")", ";", "op1", "=", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ";", "op2", "=", "constm1_rtx", ";", "if", "(", "code", "==", "EQ", ")", "reverse", "=", "true", ";", "break", ";", "case", "LEU", ":", "case", "GEU", ":", "code", "=", "reverse_condition", "(", "code", ")", ";", "reverse", "=", "true", ";", "case", "LTU", ":", "case", "GTU", ":", "if", "(", "code", "==", "GTU", ")", "{", "rtx", "tmp", "=", "op1", ";", "op1", "=", "op2", ";", "op2", "=", "tmp", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sltu", "=", "gen_rtx_LTU", "(", "SImode", ",", "op1", ",", "op2", ")", ";", "if", "(", "reverse", ")", "{", "rtx", "tmp", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_rtx_NEG", "(", "SImode", ",", "sltu", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "op0", ",", "tmp", ",", "const1_rtx", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "sltu", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "cstore", "of", "OPERANDS", "in", "MODE", "for", "EQ/NE/LTU/GTU/GEU/LEU", ".", "We", "generate", "the", "result", "in", "the", "C", "flag", "and", "use", "the", "ADC/SUBC", "instructions", "to", "write", "it", "into", "the", "destination", "register", ".", "It", "would", "also", "be", "possible", "to", "implement", "support", "for", "LT/GT/LE/GE", "by", "means", "of", "the", "RFLAG", "instruction", "followed", "by", "some", "shifts", ",", "but", "this", "can", "pessimize", "the", "generated", "code", "." ]

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

[]

[ "<s>", "static", "unsigned", "int", "h8300_classify_operand", "(", "rtx", "op", ",", "int", "size", ",", "enum", "h8300_operand_class", "*", "opclass", ")", "{", "enum", "h8300_operand_class", "dummy", ";", "if", "(", "opclass", "==", "0", ")", "opclass", "=", "&", "dummy", ";", "if", "(", "CONSTANT_P", "(", "op", ")", ")", "{", "*", "opclass", "=", "H8OP_IMMEDIATE", ";", "if", "(", "size", "==", "1", ")", "return", "0", ";", "if", "(", "TARGET_H8300SX", "&&", "size", "==", "4", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "IN_RANGE", "(", "INTVAL", "(", "op", ")", ",", "0", ",", "0xffff", ")", ")", "return", "2", ";", "return", "size", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "CONSTANT_P", "(", "op", ")", ")", "{", "*", "opclass", "=", "H8OP_MEM_ABSOLUTE", ";", "return", "h8300_constant_length", "(", "op", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", "&&", "CONSTANT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "*", "opclass", "=", "H8OP_MEM_COMPLEX", ";", "return", "h8300_displacement_length", "(", "op", ",", "size", ")", ";", "}", "else", "if", "(", "GET_RTX_CLASS", "(", "GET_CODE", "(", "op", ")", ")", "==", "RTX_AUTOINC", ")", "{", "*", "opclass", "=", "H8OP_MEM_COMPLEX", ";", "return", "0", ";", "}", "else", "if", "(", "register_operand", "(", "op", ",", "VOIDmode", ")", ")", "{", "*", "opclass", "=", "H8OP_MEM_BASE", ";", "return", "0", ";", "}", "}", "gcc_assert", "(", "register_operand", "(", "op", ",", "VOIDmode", ")", ")", ";", "*", "opclass", "=", "H8OP_REGISTER", ";", "return", "0", ";", "}", "</s>" ]

[ "Store", "the", "class", "of", "operand", "OP", "in", "*", "CLASS", "and", "return", "the", "length", "of", "any", "extra", "operand", "fields", ".", "SIZE", "is", "the", "number", "of", "bytes", "in", "OP", ".", "CLASS", "can", "be", "null", "if", "only", "the", "length", "is", "needed", "." ]

[ "h8300", "0", "1", "0", "4", "0", "0xffff", "2", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isZExtFree", "(", "EVT", "Src", ",", "EVT", "Dest", ")", "const", "{", "if", "(", "Src", "==", "MVT", "::", "i16", ")", "return", "Dest", "==", "MVT", "::", "i32", "||", "Dest", "==", "MVT", "::", "i64", ";", "return", "Src", "==", "MVT", "::", "i32", "&&", "Dest", "==", "MVT", "::", "i64", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "MVT::i16", "MVT::i32", "MVT::i64", "MVT::i32", "MVT::i64" ]

[]

[ "<s>", "int", "aarch64_vec_fpconst_pow_of_2", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_VECTOR", ")", "return", "-", "1", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "!=", "MODE_VECTOR_FLOAT", ")", "return", "-", "1", ";", "int", "firstval", "=", "aarch64_fpconst_pow_of_2", "(", "CONST_VECTOR_ELT", "(", "x", ",", "0", ")", ")", ";", "if", "(", "firstval", "<=", "0", ")", "return", "-", "1", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "i", "++", ")", "if", "(", "aarch64_fpconst_pow_of_2", "(", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ")", "!=", "firstval", ")", "return", "-", "1", ";", "return", "firstval", ";", "}", "</s>" ]

[ "If", "X", "is", "a", "vector", "of", "equal", "CONST_DOUBLE", "values", "and", "that", "value", "is", "Y", ",", "return", "the", "aarch64_fpconst_pow_of_2", "of", "Y", ".", "Otherwise", "return", "-1", "." ]

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

[]

[ "<s>", "static", "inline", "bool", "is_fast_interrupt_func", "(", "const_tree", "decl", ")", "{", "return", "has_func_attr", "(", "decl", ",", "\"fast_interrupt\"", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "provided", "function", "has", "the", "``", "fast_interrupt", "''", "attribute", "." ]

[ "rx", "\"fast_interrupt\"" ]

[]

[ "<s>", "SDNode", "*", "PIC16DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "N", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "PIC16", "PIC16" ]

[]

[ "<s>", "rtx", "s390_return_addr_rtx", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "int", "offset", ";", "rtx", "addr", ";", "if", "(", "!", "TARGET_BACKCHAIN", "&&", "count", ">", "0", ")", "return", "NULL_RTX", ";", "if", "(", "count", "==", "0", ")", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_REGNUM", ")", ";", "if", "(", "TARGET_PACKED_STACK", ")", "offset", "=", "-", "2", "*", "UNITS_PER_LONG", ";", "else", "offset", "=", "RETURN_REGNUM", "*", "UNITS_PER_LONG", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "frame", ",", "offset", ")", ";", "addr", "=", "memory_address", "(", "Pmode", ",", "addr", ")", ";", "return", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "representing", "the", "value", "of", "the", "return", "address", "for", "the", "frame", "COUNT", "steps", "up", "from", "the", "current", "frame", ".", "FRAME", "is", "the", "frame", "pointer", "of", "that", "frame", "." ]

[ "s390", "0", "0", "2" ]

[]

[ "<s>", "bool", "VERegisterInfo", "::", "isConstantPhysReg", "(", "MCRegister", "PhysReg", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "PhysReg", "is", "unallocatable", "and", "constant", "throughout", "the", "function", "." ]

[ "VE", "VE" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Z80old Expand Pseudo Instructions\"", ";", "}", "</s>" ]

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

[ "Z80old", "\"Z80old Expand Pseudo Instructions\"" ]

[]

[ "<s>", "unsigned", "int", "TMS320C64XRegisterInfo", "::", "getSubReg", "(", "unsigned", "int", ",", "unsigned", "int", ")", "const", "{", "llvm_unreachable", "(", "\"Unimplemented function getSubReg\\n\"", ")", ";", "}", "</s>" ]

[ "Returns", "the", "physical", "register", "number", "of", "sub-register", "``", "Index", "''", "for", "physical", "register", "RegNo", "." ]

[ "TMS320C64X", "TMS320C64X", "\"Unimplemented function getSubReg\\n\"" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "SP", "::", "SAVEri", ";", "unsigned", "SAVErr", "=", "SP", "::", "SAVErr", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "SAVEri", "=", "SP", "::", "ADDri", ";", "SAVErr", "=", "SP", "::", "ADDrr", ";", "}", "NumBytes", "=", "-", "SubTarget", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "SAVErr", ",", "SAVEri", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MCSymbol", "*", "FrameLabel", "=", "MMI", ".", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "PROLOG_LABEL", ")", ")", ".", "addSym", "(", "FrameLabel", ")", ";", "unsigned", "regFP", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I6", ",", "true", ")", ";", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "FrameLabel", ",", "regFP", ")", ")", ";", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createWindowSave", "(", "FrameLabel", ")", ")", ";", "unsigned", "regInRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I7", ",", "true", ")", ";", "unsigned", "regOutRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "O7", ",", "true", ")", ";", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRegister", "(", "FrameLabel", ",", "regOutRA", ",", "regInRA", ")", ")", ";", "}", "</s>" ]

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

[ "WDC65816", "SP::SAVEri", "SP::SAVErr", "0", "SP::ADDri", "SP::ADDrr", "SP::PROLOG_LABEL", "SP::I6", "SP::I7", "SP::O7" ]

[]

[ "<s>", "ArrayRef", "<", "MCPhysReg", ">", "MipsABIInfo", "::", "GetByValArgRegs", "(", ")", "const", "{", "if", "(", "IsCheriPureCap", "(", ")", ")", "return", "{", "}", ";", "if", "(", "IsO32", "(", ")", ")", "return", "makeArrayRef", "(", "O32IntRegs", ")", ";", "if", "(", "IsN32", "(", ")", "||", "IsN64", "(", ")", ")", "return", "makeArrayRef", "(", "Mips64IntRegs", ")", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "The", "registers", "to", "use", "for", "byval", "arguments", "." ]

[ "Mips", "Mips", "Mips", "\"Unhandled ABI\"" ]

[]

[ "<s>", "static", "rtx", "function_arg_record_value", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "int", "slotno", ",", "bool", "named", ",", "int", "regbase", ")", "{", "HOST_WIDE_INT", "typesize", "=", "int_size_in_bytes", "(", "type", ")", ";", "assign_data_t", "data", ";", "int", "nregs", ";", "data", ".", "slotno", "=", "slotno", ";", "data", ".", "regbase", "=", "regbase", ";", "data", ".", "nregs", "=", "0", ";", "data", ".", "intoffset", "=", "0", ";", "data", ".", "stack", "=", "false", ";", "traverse_record_type", "<", "assign_data_t", ",", "count_registers", ">", "(", "type", ",", "named", ",", "&", "data", ")", ";", "if", "(", "compute_int_layout", "(", "typesize", "*", "BITS_PER_UNIT", ",", "&", "data", ",", "&", "nregs", ")", ")", "data", ".", "nregs", "+=", "nregs", ";", "nregs", "=", "data", ".", "nregs", ";", "if", "(", "nregs", "==", "0", ")", "{", "if", "(", "typesize", "<=", "0", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "regbase", ")", ";", "}", "nregs", "=", "(", "typesize", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "nregs", "+", "slotno", ">", "SPARC_INT_ARG_MAX", ")", "nregs", "=", "SPARC_INT_ARG_MAX", "-", "slotno", ";", "}", "gcc_assert", "(", "nregs", ">", "0", ")", ";", "data", ".", "ret", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "data", ".", "stack", "+", "nregs", ")", ")", ";", "if", "(", "data", ".", "stack", ")", "XVECEXP", "(", "data", ".", "ret", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "data", ".", "nregs", "=", "0", ";", "data", ".", "intoffset", "=", "0", ";", "traverse_record_type", "<", "assign_data_t", ",", "assign_registers", ">", "(", "type", ",", "named", ",", "&", "data", ")", ";", "assign_int_registers", "(", "typesize", "*", "BITS_PER_UNIT", ",", "&", "data", ")", ";", "gcc_assert", "(", "data", ".", "nregs", "==", "nregs", ")", ";", "return", "data", ".", "ret", ";", "}", "</s>" ]

[ "Used", "by", "function_arg", "and", "sparc_function_value_1", "to", "implement", "the", "complex", "conventions", "of", "the", "64-bit", "ABI", "for", "passing", "and", "returning", "structures", ".", "Return", "an", "expression", "valid", "as", "a", "return", "value", "for", "the", "FUNCTION_ARG", "and", "TARGET_FUNCTION_VALUE", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "SLOTNO", "is", "the", "index", "number", "of", "the", "argument", "'s", "slot", "in", "the", "parameter", "array", ".", "NAMED", "is", "true", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "REGBASE", "is", "the", "regno", "of", "the", "base", "register", "for", "the", "parameter", "array", "." ]

[ "sparc", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64allRegClassID", "AArch64::tcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "RCPair", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPRRegClass", ")", ";", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'h'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "hGPRRegClass", ")", ";", "break", ";", "case", "'r'", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPRRegClass", ")", ";", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPRRegClass", ")", ";", "break", ";", "case", "'x'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPR_8RegClass", ")", ";", "break", ";", "case", "'t'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "break", ";", "}", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "unsigned", "(", "ARM", "::", "CPSR", ")", ",", "&", "ARM", "::", "CCRRegClass", ")", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "ARM", "ARM", "1", "0", "0U", "ARM::tGPRRegClass", "0U", "ARM::GPRRegClass", "0U", "ARM::hGPRRegClass", "0U", "ARM::tGPRRegClass", "0U", "ARM::GPRRegClass", "MVT::Other", "MVT::f32", "0U", "ARM::SPRRegClass", "64", "0U", "ARM::DPRRegClass", "128", "0U", "ARM::QPRRegClass", "MVT::Other", "MVT::f32", "0U", "ARM::SPR_8RegClass", "64", "0U", "ARM::DPR_8RegClass", "128", "0U", "ARM::QPR_8RegClass", "MVT::f32", "0U", "ARM::SPRRegClass", "\"{cc}\"", "ARM::CPSR", "ARM::CCRRegClass" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", ".", "optForSize", "(", ")", ";", "OptForMinSize", "=", "MF", "->", "getFunction", "(", ")", ".", "optForMinSize", "(", ")", ";", "assert", "(", "(", "!", "OptForMinSize", "||", "OptForSize", ")", "&&", "\"OptForMinSize implies OptForSize\"", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "&", "*", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "!", "Subtarget", "->", "useRetpoline", "(", ")", "&&", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "&&", "!", "Subtarget", "->", "slowTwoMemOps", "(", ")", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "!", "getTargetMachine", "(", ")", ".", "isPositionIndependent", "(", ")", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "moveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "MVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getSimpleValueType", "(", ")", ";", "MVT", "DstVT", "=", "N", "->", "getSimpleValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "const", "X86TargetLowering", "*", "X86Lowering", "=", "static_cast", "<", "const", "X86TargetLowering", "*", ">", "(", "TLI", ")", ";", "bool", "SrcIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "MVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "\"OptForMinSize implies OptForSize\"", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "X86", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "ISD::EXTLOAD", "0" ]

[]

[ "<s>", "static", "int", "getRegClass", "(", "RegisterKind", "Is", ",", "unsigned", "RegWidth", ")", "{", "if", "(", "Is", "==", "IS_VGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "VGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "VReg_64RegClassID", ";", "case", "3", ":", "return", "AMDGPU", "::", "VReg_96RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "VReg_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "VReg_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "VReg_512RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_TTMP", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "TTMP_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "TTMP_64RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "TTMP_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "TTMP_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "TTMP_512RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_SGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "SGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "SGPR_64RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "SGPR_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "SGPR_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "SGPR_512RegClassID", ";", "}", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Given", "a", "machine", "instruction", "descriptor", ",", "returns", "the", "register", "class", "constraint", "for", "OpNum", ",", "or", "NULL", "." ]

[ "AMDGPU", "1", "1", "AMDGPU::VGPR_32RegClassID", "2", "AMDGPU::VReg_64RegClassID", "3", "AMDGPU::VReg_96RegClassID", "4", "AMDGPU::VReg_128RegClassID", "8", "AMDGPU::VReg_256RegClassID", "16", "AMDGPU::VReg_512RegClassID", "1", "1", "AMDGPU::TTMP_32RegClassID", "2", "AMDGPU::TTMP_64RegClassID", "4", "AMDGPU::TTMP_128RegClassID", "8", "AMDGPU::TTMP_256RegClassID", "16", "AMDGPU::TTMP_512RegClassID", "1", "1", "AMDGPU::SGPR_32RegClassID", "2", "AMDGPU::SGPR_64RegClassID", "4", "AMDGPU::SGPR_128RegClassID", "8", "AMDGPU::SGPR_256RegClassID", "16", "AMDGPU::SGPR_512RegClassID", "1" ]

[]

[ "<s>", "int", "sh_max_mov_insn_displacement", "(", "machine_mode", "mode", ",", "bool", "consider_sh2a", ")", "{", "const", "int", "disp_scale", "=", "consider_sh2a", "?", "(", "4095", "/", "15", ")", ":", "1", ";", "if", "(", "!", "consider_sh2a", "&&", "TARGET_FPU_ANY", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "0", ";", "else", "{", "const", "int", "mov_insn_sz", "=", "mov_insn_size", "(", "mode", ",", "consider_sh2a", ")", ";", "const", "int", "mode_sz", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "int", "r", "=", "15", "*", "mov_insn_sz", "*", "disp_scale", ";", "if", "(", "mode_sz", ">", "mov_insn_sz", ")", "r", "-=", "mode_sz", "-", "mov_insn_sz", ";", "return", "r", ";", "}", "}", "</s>" ]

[ "Determine", "the", "maximum", "possible", "displacement", "for", "a", "move", "insn", "for", "the", "specified", "mode", "." ]

[ "sh", "4095", "15", "1", "0", "15" ]

[]

[ "<s>", "static", "inline", "int", "regno_or_subregno", "(", "rtx", "op", ")", "{", "if", "(", "REG_P", "(", "op", ")", ")", "return", "REGNO", "(", "op", ")", ";", "else", "if", "(", "SUBREG_P", "(", "op", ")", ")", "return", "subreg_regno", "(", "op", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "return", "the", "register", "number", "of", "a", "RTX", "." ]

[ "rs6000" ]

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "emitLoadLinked", "(", "IRBuilderBase", "&", "Builder", ",", "Type", "*", "ValueTy", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsAcquire", "=", "isAcquireOrStronger", "(", "Ord", ")", ";", "if", "(", "ValueTy", "->", "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", ",", "ValueTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValueTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValueTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxr", ":", "Intrinsic", "::", "aarch64_ldxr", ";", "Function", "*", "Ldxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "const", "DataLayout", "&", "DL", "=", "M", "->", "getDataLayout", "(", ")", ";", "IntegerType", "*", "IntEltTy", "=", "Builder", ".", "getIntNTy", "(", "DL", ".", "getTypeSizeInBits", "(", "ValueTy", ")", ")", ";", "Value", "*", "Trunc", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ")", ",", "IntEltTy", ")", ";", "return", "Builder", ".", "CreateBitCast", "(", "Trunc", ",", "ValueTy", ")", ";", "}", "</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>", "ScheduleHazardRecognizer", "::", "HazardType", "SystemZHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "return", "(", "fitsIntoCurrentGroup", "(", "SU", ")", "?", "NoHazard", ":", "Hazard", ")", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "SystemZ", "SystemZ" ]

[]