Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "matches_type_p", "(", "const_tree", "model_type", ",", "const_tree", "candidate", ")", "{", "if", "(", "VECTOR_TYPE_P", "(", "model_type", ")", ")", "{", "if", "(", "!", "VECTOR_TYPE_P", "(", "candidate", ")", "||", "maybe_ne", "(", "TYPE_VECTOR_SUBPARTS", "(", "model_type", ")", ",", "TYPE_VECTOR_SUBPARTS", "(", "candidate", ")", ")", "||", "TYPE_MODE", "(", "model_type", ")", "!=", "TYPE_MODE", "(", "candidate", ")", ")", "return", "false", ";", "model_type", "=", "TREE_TYPE", "(", "model_type", ")", ";", "candidate", "=", "TREE_TYPE", "(", "candidate", ")", ";", "}", "return", "(", "candidate", "!=", "error_mark_node", "&&", "TYPE_MAIN_VARIANT", "(", "model_type", ")", "==", "TYPE_MAIN_VARIANT", "(", "candidate", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "CANDIDATE", "is", "equivalent", "to", "MODEL_TYPE", "for", "overloading", "purposes", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "bool", "isF128SoftLibCall", "(", "const", "char", "*", "CallSym", ")", "{", "const", "char", "*", "const", "LibCalls", "[", "]", "=", "{", "\"__addtf3\"", ",", "\"__divtf3\"", ",", "\"__eqtf2\"", ",", "\"__extenddftf2\"", ",", "\"__extendsftf2\"", ",", "\"__fixtfdi\"", ",", "\"__fixtfsi\"", ",", "\"__fixtfti\"", ",", "\"__fixunstfdi\"", ",", "\"__fixunstfsi\"", ",", "\"__fixunstfti\"", ",", "\"__floatditf\"", ",", "\"__floatsitf\"", ",", "\"__floattitf\"", ",", "\"__floatunditf\"", ",", "\"__floatunsitf\"", ",", "\"__floatuntitf\"", ",", "\"__getf2\"", ",", "\"__gttf2\"", ",", "\"__letf2\"", ",", "\"__lttf2\"", ",", "\"__multf3\"", ",", "\"__netf2\"", ",", "\"__powitf2\"", ",", "\"__subtf3\"", ",", "\"__trunctfdf2\"", ",", "\"__trunctfsf2\"", ",", "\"__unordtf2\"", ",", "\"ceill\"", ",", "\"copysignl\"", ",", "\"cosl\"", ",", "\"exp2l\"", ",", "\"expl\"", ",", "\"floorl\"", ",", "\"fmal\"", ",", "\"fmaxl\"", ",", "\"fmodl\"", ",", "\"log10l\"", ",", "\"log2l\"", ",", "\"logl\"", ",", "\"nearbyintl\"", ",", "\"powl\"", ",", "\"rintl\"", ",", "\"roundl\"", ",", "\"sinl\"", ",", "\"sqrtl\"", ",", "\"truncl\"", "}", ";", "auto", "Comp", "=", "[", "]", "(", "const", "char", "*", "S1", ",", "const", "char", "*", "S2", ")", "{", "return", "strcmp", "(", "S1", ",", "S2", ")", "<", "0", ";", "}", ";", "assert", "(", "llvm", "::", "is_sorted", "(", "LibCalls", ",", "Comp", ")", ")", ";", "return", "std", "::", "binary_search", "(", "std", "::", "begin", "(", "LibCalls", ")", ",", "std", "::", "end", "(", "LibCalls", ")", ",", "CallSym", ",", "Comp", ")", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "CallSym", "is", "a", "long", "double", "emulation", "routine", "." ]

[ "Mips", "\"__addtf3\"", "\"__divtf3\"", "\"__eqtf2\"", "\"__extenddftf2\"", "\"__extendsftf2\"", "\"__fixtfdi\"", "\"__fixtfsi\"", "\"__fixtfti\"", "\"__fixunstfdi\"", "\"__fixunstfsi\"", "\"__fixunstfti\"", "\"__floatditf\"", "\"__floatsitf\"", "\"__floattitf\"", "\"__floatunditf\"", "\"__floatunsitf\"", "\"__floatuntitf\"", "\"__getf2\"", "\"__gttf2\"", "\"__letf2\"", "\"__lttf2\"", "\"__multf3\"", "\"__netf2\"", "\"__powitf2\"", "\"__subtf3\"", "\"__trunctfdf2\"", "\"__trunctfsf2\"", "\"__unordtf2\"", "\"ceill\"", "\"copysignl\"", "\"cosl\"", "\"exp2l\"", "\"expl\"", "\"floorl\"", "\"fmal\"", "\"fmaxl\"", "\"fmodl\"", "\"log10l\"", "\"log2l\"", "\"logl\"", "\"nearbyintl\"", "\"powl\"", "\"rintl\"", "\"roundl\"", "\"sinl\"", "\"sqrtl\"", "\"truncl\"", "0" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "if", "(", "!", "SIInstrInfo", "::", "isMUBUF", "(", "*", "MI", ")", ")", "return", "false", ";", "int64_t", "NewOffset", "=", "Offset", "+", "getMUBUFInstrOffset", "(", "MI", ")", ";", "return", "SIInstrInfo", "::", "isLegalMUBUFImmOffset", "(", "NewOffset", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

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

[]

[ "<s>", "Value", "*", "RISCVTargetLowering", "::", "emitMaskedAtomicRMWIntrinsic", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "AtomicRMWInst", "*", "AI", ",", "Value", "*", "AlignedAddr", ",", "Value", "*", "Incr", ",", "Value", "*", "Mask", ",", "Value", "*", "ShiftAmt", ",", "AtomicOrdering", "Ord", ")", "const", "{", "unsigned", "XLen", "=", "Subtarget", ".", "getXLen", "(", ")", ";", "Value", "*", "Ordering", "=", "Builder", ".", "getIntN", "(", "XLen", ",", "static_cast", "<", "uint64_t", ">", "(", "AI", "->", "getOrdering", "(", ")", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "AlignedAddr", "->", "getType", "(", ")", "}", ";", "Function", "*", "LrwOpScwLoop", "=", "Intrinsic", "::", "getDeclaration", "(", "AI", "->", "getModule", "(", ")", ",", "getIntrinsicForMaskedAtomicRMWBinOp", "(", "XLen", ",", "AI", "->", "getOperation", "(", ")", ")", ",", "Tys", ")", ";", "if", "(", "XLen", "==", "64", ")", "{", "Incr", "=", "Builder", ".", "CreateSExt", "(", "Incr", ",", "Builder", ".", "getInt64Ty", "(", ")", ")", ";", "Mask", "=", "Builder", ".", "CreateSExt", "(", "Mask", ",", "Builder", ".", "getInt64Ty", "(", ")", ")", ";", "ShiftAmt", "=", "Builder", ".", "CreateSExt", "(", "ShiftAmt", ",", "Builder", ".", "getInt64Ty", "(", ")", ")", ";", "}", "Value", "*", "Result", ";", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Min", "||", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Max", ")", "{", "const", "DataLayout", "&", "DL", "=", "AI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "ValWidth", "=", "DL", ".", "getTypeStoreSizeInBits", "(", "AI", "->", "getValOperand", "(", ")", "->", "getType", "(", ")", ")", ";", "Value", "*", "SextShamt", "=", "Builder", ".", "CreateSub", "(", "Builder", ".", "getIntN", "(", "XLen", ",", "XLen", "-", "ValWidth", ")", ",", "ShiftAmt", ")", ";", "Result", "=", "Builder", ".", "CreateCall", "(", "LrwOpScwLoop", ",", "{", "AlignedAddr", ",", "Incr", ",", "Mask", ",", "SextShamt", ",", "Ordering", "}", ")", ";", "}", "else", "{", "Result", "=", "Builder", ".", "CreateCall", "(", "LrwOpScwLoop", ",", "{", "AlignedAddr", ",", "Incr", ",", "Mask", ",", "Ordering", "}", ")", ";", "}", "if", "(", "XLen", "==", "64", ")", "Result", "=", "Builder", ".", "CreateTrunc", "(", "Result", ",", "Builder", ".", "getInt32Ty", "(", ")", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Perform", "a", "masked", "atomicrmw", "using", "a", "target-specific", "intrinsic", "." ]

[ "RISCV", "RISCV", "Intrinsic::getDeclaration", "64", "64" ]

[]

[ "<s>", "int", "ix86_data_alignment", "(", "tree", "type", ",", "int", "align", ",", "bool", "opt", ")", "{", "int", "max_align_compat", "=", "MIN", "(", "256", ",", "MAX_OFILE_ALIGNMENT", ")", ";", "int", "max_align", "=", "MIN", "(", "(", "unsigned", ")", "ix86_tune_cost", "->", "prefetch_block", "*", "8", ",", "MAX_OFILE_ALIGNMENT", ")", ";", "if", "(", "max_align", "<", "BITS_PER_WORD", ")", "max_align", "=", "BITS_PER_WORD", ";", "switch", "(", "ix86_align_data_type", ")", "{", "case", "ix86_align_data_type_abi", ":", "opt", "=", "false", ";", "break", ";", "case", "ix86_align_data_type_compat", ":", "max_align", "=", "BITS_PER_WORD", ";", "break", ";", "case", "ix86_align_data_type_cacheline", ":", "break", ";", "}", "if", "(", "opt", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", ")", "{", "if", "(", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "max_align_compat", ")", "&&", "align", "<", "max_align_compat", ")", "align", "=", "max_align_compat", ";", "if", "(", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "max_align", ")", "&&", "align", "<", "max_align", ")", "align", "=", "max_align", ";", "}", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "(", "opt", "?", "AGGREGATE_TYPE_P", "(", "type", ")", ":", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "128", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "if", "(", "!", "opt", ")", "return", "align", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DCmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "(", "TYPE_MODE", "(", "type", ")", "==", "XCmode", "||", "TYPE_MODE", "(", "type", ")", "==", "TCmode", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "QUAL_UNION_TYPE", ")", "&&", "TYPE_FIELDS", "(", "type", ")", ")", "{", "if", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "type", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "return", "align", ";", "}", "</s>" ]

[ "Compute", "the", "alignment", "for", "a", "static", "variable", ".", "TYPE", "is", "the", "data", "type", ",", "and", "ALIGN", "is", "the", "alignment", "that", "the", "object", "would", "ordinarily", "have", ".", "The", "value", "of", "this", "function", "is", "used", "instead", "of", "that", "alignment", "to", "align", "the", "object", "." ]

[ "i386", "256", "8", "128", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "OpKind_Reg", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "M88k" ]

[]

[ "<s>", "int", "total_frame_size", "(", ")", "{", "unsigned", "int", "size", "=", "get_frame_size", "(", ")", ";", "unsigned", "int", "outgoing_args_size", "=", "current_function_outgoing_args_size", ";", "int", "i", ";", "if", "(", "optimize", "&&", "!", "current_function_needs_context", "&&", "!", "frame_pointer_needed", ")", "{", "int", "inline_count", ",", "outline_count", ";", "inline_count", "=", "0", ";", "if", "(", "regs_ever_live", "[", "5", "]", ")", "inline_count", "+=", "2", ";", "if", "(", "regs_ever_live", "[", "6", "]", ")", "inline_count", "+=", "2", ";", "if", "(", "regs_ever_live", "[", "2", "]", ")", "inline_count", "+=", "3", ";", "if", "(", "regs_ever_live", "[", "3", "]", ")", "inline_count", "+=", "3", ";", "if", "(", "size", "||", "outgoing_args_size", "||", "regs_ever_live", "[", "5", "]", "||", "regs_ever_live", "[", "6", "]", "||", "regs_ever_live", "[", "2", "]", "||", "regs_ever_live", "[", "3", "]", ")", "inline_count", "+=", "2", ";", "inline_count", "=", "inline_count", "*", "2", "+", "1", ";", "outline_count", "=", "3", ";", "outline_count", "+=", "(", "outgoing_args_size", "==", "0", "?", "0", ":", "2", ")", ";", "if", "(", "get_frame_size", "(", ")", "!=", "0", ")", "outline_count", "+=", "2", ";", "outline_count", "=", "outline_count", "*", "2", "+", "1", ";", "if", "(", "get_frame_size", "(", ")", "==", "0", "&&", "outgoing_args_size", "==", "0", ")", "outline_count", "-=", "1", ";", "if", "(", "inline_count", ">", "outline_count", ")", "return", "size", "+", "outgoing_args_size", "+", "16", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", "&&", "!", "fixed_regs", "[", "i", "]", ")", "||", "(", "i", "==", "FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", ")", "size", "+=", "4", ";", "}", "return", "(", "size", "+", "outgoing_args_size", ")", ";", "}", "</s>" ]

[ "Return", "the", "total", "size", "(", "in", "bytes", ")", "of", "the", "current", "function", "'s", "frame", ".", "This", "is", "the", "size", "of", "the", "register", "save", "area", "+", "the", "size", "of", "locals", ",", "spills", ",", "etc", "." ]

[ "mn10200", "0", "5", "2", "6", "2", "2", "3", "3", "3", "5", "6", "2", "3", "2", "2", "1", "3", "0", "0", "2", "0", "2", "2", "1", "0", "0", "1", "16", "0", "4" ]

[]

[ "<s>", "const", "char", "*", "emit_fusion_gpr_load", "(", "rtx", "target", ",", "rtx", "mem", ")", "{", "rtx", "addis_value", ";", "rtx", "addr", ";", "rtx", "load_offset", ";", "const", "char", "*", "load_str", "=", "NULL", ";", "machine_mode", "mode", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "ZERO_EXTEND", ")", "mem", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "target", ")", "&&", "MEM_P", "(", "mem", ")", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "fusion_split_address", "(", "addr", ",", "&", "addis_value", ",", "&", "load_offset", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "load_str", "=", "\"lbz\"", ";", "break", ";", "case", "E_HImode", ":", "load_str", "=", "\"lhz\"", ";", "break", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "load_str", "=", "\"lwz\"", ";", "break", ";", "case", "E_DImode", ":", "case", "E_DFmode", ":", "gcc_assert", "(", "TARGET_POWERPC64", ")", ";", "load_str", "=", "\"ld\"", ";", "break", ";", "default", ":", "fatal_insn", "(", "\"Bad GPR fusion\"", ",", "gen_rtx_SET", "(", "target", ",", "mem", ")", ")", ";", "}", "emit_fusion_addis", "(", "target", ",", "addis_value", ")", ";", "emit_fusion_load", "(", "target", ",", "target", ",", "load_offset", ",", "load_str", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "fuse", "an", "addis", "instruction", "with", "a", "gpr", "load", "to", "the", "same", "register", "that", "we", "loaded", "up", "the", "addis", "instruction", ".", "The", "address", "that", "is", "used", "is", "the", "logical", "address", "that", "was", "formed", "during", "peephole2", ":", "(", "lo_sum", "(", "high", ")", "(", "low-part", ")", ")", "The", "code", "is", "complicated", ",", "so", "we", "call", "output_asm_insn", "directly", ",", "and", "just", "return", "``", "''", "." ]

[ "rs6000", "0", "0", "\"lbz\"", "\"lhz\"", "\"lwz\"", "\"ld\"", "\"Bad GPR fusion\"", "\"\"" ]

[]

[ "<s>", "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "bool", "Is64Bit", "=", "TM", "->", "getSubtargetImpl", "(", ")", "->", "isPPC64", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "GETtlsADDR", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "GETtlsldADDR", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "GETtlsADDR32", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "GETtlsldADDR32", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"TLS Dynamic Call Fixup:\\n \"", "<<", "*", "MI", ";", ")", ";", "unsigned", "OutReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "InReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "GPR3", "=", "Is64Bit", "?", "PPC", "::", "X3", ":", "PPC", "::", "R3", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "GPR3", ")", ".", "addReg", "(", "InReg", ")", ";", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "GPR3", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setReg", "(", "GPR3", ")", ";", "BuildMI", "(", "MBB", ",", "++", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "OutReg", ")", ".", "addReg", "(", "GPR3", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "PowerPC", "PPC", "PPC::GETtlsADDR", "PPC::GETtlsldADDR", "PPC::GETtlsADDR32", "PPC::GETtlsldADDR32", "\"TLS Dynamic Call Fixup:\\n \"", "0", "1", "PPC::X3", "PPC::R3", "0", "1" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldClusterMemOps", "(", "MachineInstr", "&", "FirstLdSt", ",", "MachineInstr", "&", "SecondLdSt", ",", "unsigned", "NumLoads", ")", "const", "{", "if", "(", "NumLoads", ">", "1", ")", "return", "false", ";", "unsigned", "FirstOpc", "=", "FirstLdSt", ".", "getOpcode", "(", ")", ";", "unsigned", "SecondOpc", "=", "SecondLdSt", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "canPairLdStOpc", "(", "FirstOpc", ",", "SecondOpc", ")", ")", "return", "false", ";", "if", "(", "!", "isCandidateToMergeOrPair", "(", "FirstLdSt", ")", "||", "!", "isCandidateToMergeOrPair", "(", "SecondLdSt", ")", ")", "return", "false", ";", "int64_t", "Offset1", "=", "FirstLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "FirstOpc", ")", "&&", "!", "scaleOffset", "(", "FirstOpc", ",", "Offset1", ")", ")", "return", "false", ";", "int64_t", "Offset2", "=", "SecondLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "SecondOpc", ")", "&&", "!", "scaleOffset", "(", "SecondOpc", ",", "Offset2", ")", ")", "return", "false", ";", "if", "(", "Offset1", ">", "63", "||", "Offset1", "<", "-", "64", ")", "return", "false", ";", "assert", "(", "Offset1", "<=", "Offset2", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "return", "Offset1", "+", "1", "==", "Offset2", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "2", "2", "63", "64", "\"Caller should have ordered offsets.\"", "1" ]

[]

[ "<s>", "static", "rtx", "arm_trampoline_adjust_address", "(", "rtx", "addr", ")", "{", "if", "(", "TARGET_THUMB", ")", "addr", "=", "expand_simple_binop", "(", "Pmode", ",", "IOR", ",", "addr", ",", "const1_rtx", ",", "NULL", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", ";", "return", "addr", ";", "}", "</s>" ]

[ "Thumb", "trampolines", "should", "be", "entered", "in", "thumb", "mode", ",", "so", "set", "the", "bottom", "bit", "of", "the", "address", "." ]

[ "arm", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "addPass", "(", "createRISCVOptimizeVSETVLUsesPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "static", "rtx", "tilepro_got_symbol", "(", "void", ")", "{", "if", "(", "g_got_symbol", "==", "NULL", ")", "g_got_symbol", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ")", ";", "return", "g_got_symbol", ";", "}", "</s>" ]

[ "Return", "the", "SYMBOL_REF", "for", "_GLOBAL_OFFSET_TABLE_", "." ]

[ "tilepro", "\"_GLOBAL_OFFSET_TABLE_\"" ]

[]

[ "<s>", "bool", "AArch64A57FPLoadBalancing", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64A57FPLoadBalancing *****\\n\"", ")", ";", "MRI", "=", "&", "F", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "F", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "RCI", ".", "runOnMachineFunction", "(", "F", ")", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "Changed", "|=", "runOnBasicBlock", "(", "MBB", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64A57FPLoadBalancing *****\\n\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM64 Store Pair Suppression\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 Store Pair Suppression\"" ]

[]

[ "<s>", "ConvergingVLIWScheduler", "::", "CandResult", "ConvergingVLIWScheduler", "::", "pickNodeFromQueue", "(", "ReadyQueue", "&", "Q", ",", "const", "RegPressureTracker", "&", "RPTracker", ",", "SchedCandidate", "&", "Candidate", ")", "{", "DEBUG", "(", "Q", ".", "dump", "(", ")", ")", ";", "RegPressureTracker", "&", "TempTracker", "=", "const_cast", "<", "RegPressureTracker", "&", ">", "(", "RPTracker", ")", ";", "CandResult", "FoundCandidate", "=", "NoCand", ";", "for", "(", "ReadyQueue", "::", "iterator", "I", "=", "Q", ".", "begin", "(", ")", ",", "E", "=", "Q", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "RegPressureDelta", "RPDelta", ";", "TempTracker", ".", "getMaxPressureDelta", "(", "(", "*", "I", ")", "->", "getInstr", "(", ")", ",", "RPDelta", ",", "DAG", "->", "getRegionCriticalPSets", "(", ")", ",", "DAG", "->", "getRegPressure", "(", ")", ".", "MaxSetPressure", ")", ";", "int", "CurrentCost", "=", "SchedulingCost", "(", "Q", ",", "*", "I", ",", "Candidate", ",", "RPDelta", ",", "false", ")", ";", "if", "(", "!", "Candidate", ".", "SU", ")", "{", "Candidate", ".", "SU", "=", "*", "I", ";", "Candidate", ".", "RPDelta", "=", "RPDelta", ";", "Candidate", ".", "SCost", "=", "CurrentCost", ";", "FoundCandidate", "=", "NodeOrder", ";", "continue", ";", "}", "if", "(", "CurrentCost", ">", "Candidate", ".", "SCost", ")", "{", "DEBUG", "(", "traceCandidate", "(", "\"CCAND\"", ",", "Q", ",", "*", "I", ")", ")", ";", "Candidate", ".", "SU", "=", "*", "I", ";", "Candidate", ".", "RPDelta", "=", "RPDelta", ";", "Candidate", ".", "SCost", "=", "CurrentCost", ";", "FoundCandidate", "=", "BestCost", ";", "continue", ";", "}", "if", "(", "FoundCandidate", "==", "NoCand", ")", "continue", ";", "}", "return", "FoundCandidate", ";", "}", "</s>" ]

[ "Pick", "the", "best", "candidate", "from", "the", "queue", "." ]

[ "Hexagon", "\"CCAND\"" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "releasePred", "(", "SUnit", "*", "SU", ",", "SDep", "*", "PredEdge", ")", "{", "SUnit", "*", "PredSU", "=", "PredEdge", "->", "getSUnit", "(", ")", ";", "if", "(", "PredEdge", "->", "isWeak", "(", ")", ")", "{", "--", "PredSU", "->", "WeakSuccsLeft", ";", "return", ";", "}", "if", "(", "PredSU", "->", "NumSuccsLeft", "==", "0", ")", "{", "dbgs", "(", ")", "<<", "\"*** Scheduling failed! ***\\n\"", ";", "PredSU", "->", "dumpAttributes", "(", ")", ";", "dbgs", "(", ")", "<<", "\" has been released too many times!\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "--", "PredSU", "->", "NumSuccsLeft", ";", "if", "(", "PredSU", "->", "NumSuccsLeft", "==", "0", "&&", "PredSU", "!=", "&", "EntrySU", ")", "SchedImpl", "->", "releaseBottomNode", "(", "PredSU", ")", ";", "}", "</s>" ]

[ "ReleasePred", "-", "Decrement", "the", "NumSuccsLeft", "count", "of", "a", "predecessor", "." ]

[ "Patmos", "0", "\"*** Scheduling failed! ***\\n\"", "\" has been released too many times!\\n\"", "0", "0" ]

[]

[ "<s>", "static", "bool", "pa_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "int", "precision", "=", "GET_MODE_PRECISION", "(", "mode", ")", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_INT", ":", "if", "(", "precision", "==", "CHAR_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "SHORT_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "INT_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "LONG_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "LONG_LONG_TYPE_SIZE", ")", "return", "true", ";", "return", "false", ";", "case", "MODE_FLOAT", ":", "if", "(", "precision", "==", "FLOAT_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "DOUBLE_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "LONG_DOUBLE_TYPE_SIZE", ")", "return", "true", ";", "return", "false", ";", "case", "MODE_DECIMAL_FLOAT", ":", "return", "false", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "True", "if", "MODE", "is", "valid", "for", "the", "target", ".", "By", "``", "valid", "''", ",", "we", "mean", "able", "to", "be", "manipulated", "in", "non-trivial", "ways", ".", "In", "particular", ",", "this", "means", "all", "the", "arithmetic", "is", "supported", "." ]

[ "pa" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "TM", ")", "return", "false", ";", "Mod", "=", "&", "M", ";", "DL", "=", "&", "Mod", "->", "getDataLayout", "(", ")", ";", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "IsAMDGCN", "=", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ";", "IsAMDHSA", "=", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "Thumb1InstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "ARM", "::", "tPUSH", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "true", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", "&&", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "Reg", ")", ")", "isKill", "=", "false", ";", "}", "if", "(", "isKill", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM::tPUSH", "0", "1", "ARM::LR" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorClearMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "Mask", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "MVT", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "unsigned", "NumElts", "=", "SVT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "==", "2", ")", "return", "true", ";", "if", "(", "NumElts", "==", "4", "&&", "SVT", ".", "is128BitVector", "(", ")", ")", "{", "return", "(", "isMOVLMask", "(", "Mask", ",", "SVT", ")", "||", "isCommutedMOVLMask", "(", "Mask", ",", "SVT", ",", "true", ")", "||", "isSHUFPMask", "(", "Mask", ",", "SVT", ")", "||", "isSHUFPMask", "(", "Mask", ",", "SVT", ",", "true", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Similar", "to", "isShuffleMaskLegal", "." ]

[ "X86", "X86", "2", "4" ]

[]

[ "<s>", "Nios2Subtarget", "&", "Nios2Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "if", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "nios2", ")", "{", "if", "(", "CPU", "!=", "\"nios2r2\"", ")", "{", "CPU", "=", "\"nios2r1\"", ";", "Nios2ArchVersion", "=", "Nios2r1", ";", "}", "else", "{", "Nios2ArchVersion", "=", "Nios2r2", ";", "}", "}", "else", "{", "errs", "(", ")", "<<", "\"!!!Error, TargetTriple.getArch() = \"", "<<", "TargetTriple", ".", "getArch", "(", ")", "<<", "\"CPU = \"", "<<", "CPU", "<<", "\"\\n\"", ";", "exit", "(", "0", ")", ";", "}", "ParseSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "Nios2", "\"nios2r2\"", "\"nios2r1\"", "Nios2", "Nios2", "Nios2", "Nios2", "\"!!!Error, TargetTriple.getArch() = \"", "\"CPU = \"", "\"\\n\"", "0" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "llvm_unreachable", "(", "\"TLS not implemented for Sparc.\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerCONSTANTPOOL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Should not custom lower this!\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "\"TLS not implemented for Sparc.\"", "ISD::GlobalAddress", "ISD::ConstantPool", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::VASTART", "ISD::VAARG", "ISD::DYNAMIC_STACKALLOC" ]

[]

[ "<s>", "bool", "useAA", "(", ")", "const", "override", "{", "return", "isCortexA53", "(", ")", "||", "isCortexA57", "(", ")", ";", "}", "</s>" ]

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "return", "Kind", "==", "Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "X86" ]

[]

[ "<s>", "static", "int", "rs6000_reassociation_width", "(", "unsigned", "int", "opc", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "rs6000_cpu", ")", "{", "case", "PROCESSOR_POWER8", ":", "case", "PROCESSOR_POWER9", ":", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "1", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "4", ";", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", ")", "return", "opc", "==", "MULT_EXPR", "?", "4", ":", "6", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "4", ";", "break", ";", "default", ":", "break", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "reassociation", "width", "to", "be", "used", "in", "reassociate_bb", ".", "This", "takes", "into", "account", "how", "many", "parallel", "operations", "we", "can", "actually", "do", "of", "a", "given", "type", ",", "and", "also", "the", "latency", ".", "P8", ":", "int", "add/sub", "6/cycle", "mul", "2/cycle", "vect", "add/sub/mul", "2/cycle", "fp", "add/sub/mul", "2/cycle", "dfp", "1/cycle" ]

[ "rs6000", "1", "4", "4", "6", "4", "1" ]

[]

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

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

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

[]

[ "<s>", "bool", "SparcAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "printModuleLevelGV", "(", "I", ")", ";", "O", "<<", "'\\n'", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "AArch64InstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "AArch64II", ";", "if", "(", "Subtarget", ".", "isTargetCOFF", "(", ")", ")", "{", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_COFFSTUB", ",", "\"aarch64-coffstub\"", "}", ",", "{", "MO_GOT", ",", "\"aarch64-got\"", "}", ",", "{", "MO_NC", ",", "\"aarch64-nc\"", "}", ",", "{", "MO_TLS", ",", "\"aarch64-tls\"", "}", ",", "{", "MO_DLLIMPORT", ",", "\"aarch64-dllimport\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "else", "{", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_GOTOFF", ",", "\"aarch64-gotoff\"", "}", ",", "{", "MO_POT", ",", "\"aarch64-pot\"", "}", ",", "{", "MO_SEC", ",", "\"aarch64-sec\"", "}", ",", "{", "MO_GOT", ",", "\"aarch64-got\"", "}", ",", "{", "MO_NC", ",", "\"aarch64-nc\"", "}", ",", "{", "MO_TLS", ",", "\"aarch64-tls\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]

[ "AArch64", "AArch64", "AArch64", "\"aarch64-coffstub\"", "\"aarch64-got\"", "\"aarch64-nc\"", "\"aarch64-tls\"", "\"aarch64-dllimport\"", "\"aarch64-gotoff\"", "\"aarch64-pot\"", "\"aarch64-sec\"", "\"aarch64-got\"", "\"aarch64-nc\"", "\"aarch64-tls\"" ]

[]

[ "<s>", "void", "R600TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "AMDGPUTargetLowering", "::", "ReplaceNodeResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", ")", "{", "Results", ".", "push_back", "(", "LowerFPTOUINT", "(", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "{", "SDValue", "Result", ";", "if", "(", "expandFP_TO_SINT", "(", "N", ",", "Result", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "case", "ISD", "::", "SDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "1", ")", ";", "SDValue", "RES", "=", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "Results", ".", "push_back", "(", "RES", ")", ";", "Results", ".", "push_back", "(", "RES", ".", "getValue", "(", "1", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "UDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "0", ")", ";", "LowerUDIVREM64", "(", "Op", ",", "DAG", ",", "Results", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "R600", "ISD::FP_TO_UINT", "0", "MVT::i1", "0", "ISD::FP_TO_SINT", "SI", "ISD::SDIVREM", "1", "1", "ISD::UDIVREM", "0" ]

[]

[ "<s>", "Optional", "<", "DestSourcePair", ">", "AArch64InstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ORRWrs", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "WZR", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0x0", ")", "{", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "2", ")", "}", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ORRXrs", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "XZR", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0x0", ")", "{", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "2", ")", "}", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "AArch64", "AArch64", "AArch64::ORRWrs", "1", "AArch64::WZR", "3", "0x0", "0", "2", "AArch64::ORRXrs", "1", "AArch64::XZR", "3", "0x0", "0", "2" ]

[]

[ "<s>", "bool", "TOYPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createTOYPreRegAlloc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "TOY", "TOY", "TOY" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "mo", ",", "AsmPrinter", "&", "ap", ")", "{", "SmallString", "<", "128", ">", "name", ";", "const", "TargetMachine", "&", "TM", "=", "ap", ".", "TM", ";", "Mangler", "&", "Mang", "=", "TM", ".", "getObjFileLowering", "(", ")", "->", "getMangler", "(", ")", ";", "if", "(", "mo", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "gv", "=", "mo", ".", "getGlobal", "(", ")", ";", "TM", ".", "getNameWithPrefix", "(", "name", ",", "gv", ",", "Mang", ")", ";", "}", "else", "{", "assert", "(", "mo", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Mangler", "::", "getNameWithPrefix", "(", "name", ",", "mo", ".", "getSymbolName", "(", ")", ",", "ap", ".", "getDataLayout", "(", ")", ")", ";", "}", "return", "ap", ".", "OutContext", ".", "getOrCreateSymbol", "(", "name", ")", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "TGSI", "128", "\"Isn't a symbol reference\"" ]

[]

[ "<s>", "bool", "ARMCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "JTI", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "II", "=", "(", "(", "const", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "(", "(", "const", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getTargetData", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "IsThumb", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isThumbFunction", "(", ")", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"JIT relocation model must be set to static or default!\"", "ARM", "ARM", "ARM", "ARM", "0", "ARM", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "static", "rtx", "alpha_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "basereg", ";", "int", "num_args", ";", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "basereg", "=", "16", ";", "else", "{", "gcc_assert", "(", "!", "COMPLEX_MODE_P", "(", "mode", ")", ")", ";", "if", "(", "TARGET_FPREGS", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "basereg", "=", "32", "+", "16", ";", "else", "basereg", "=", "16", ";", "}", "{", "if", "(", "mode", "==", "VOIDmode", ")", "return", "alpha_arg_info_reg_val", "(", "*", "cum", ")", ";", "num_args", "=", "cum", "->", "num_args", ";", "if", "(", "num_args", ">=", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "{", "if", "(", "*", "cum", ">=", "6", ")", "return", "NULL_RTX", ";", "num_args", "=", "*", "cum", ";", "if", "(", "type", "==", "void_type_node", ")", "basereg", "=", "16", ";", "else", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "num_args", "+", "basereg", ")", ";", "}", "</s>" ]

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

[ "alpha", "16", "32", "16", "16", "6", "6", "16" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "Nios2AsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Nios2", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_Nios2_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Nios2_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Nios2_LO16\"", ",", "0", ",", "16", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "Nios2", "Nios2", "Nios2::NumTargetFixupKinds", "\"fixup_Nios2_32\"", "0", "32", "0", "\"fixup_Nios2_HI16\"", "0", "16", "0", "\"fixup_Nios2_LO16\"", "0", "16", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "avr_init_expanders", "(", "void", ")", "{", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "32", ";", "regno", "++", ")", "all_regs_rtx", "[", "regno", "]", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "lpm_reg_rtx", "=", "all_regs_rtx", "[", "LPM_REGNO", "]", ";", "tmp_reg_rtx", "=", "all_regs_rtx", "[", "AVR_TMP_REGNO", "]", ";", "zero_reg_rtx", "=", "all_regs_rtx", "[", "AVR_ZERO_REGNO", "]", ";", "cc_reg_rtx", "=", "gen_rtx_REG", "(", "CCmode", ",", "REG_CC", ")", ";", "lpm_addr_reg_rtx", "=", "gen_rtx_REG", "(", "HImode", ",", "REG_Z", ")", ";", "sreg_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "sreg", ")", ")", ";", "rampd_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampd", ")", ")", ";", "rampx_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampx", ")", ")", ";", "rampy_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampy", ")", ")", ";", "rampz_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampz", ")", ")", ";", "xstring_empty", "=", "gen_rtx_CONST_STRING", "(", "VOIDmode", ",", "\"\"", ")", ";", "xstring_e", "=", "gen_rtx_CONST_STRING", "(", "VOIDmode", ",", "\"e\"", ")", ";", "if", "(", "AVR_TINY", ")", "avr_have_dimode", "=", "false", ";", "}", "</s>" ]

[ "The", "function", "works", "like", "a", "singleton", "." ]

[ "avr", "0", "32", "\"\"", "\"e\"" ]

[]

[ "<s>", "bool", "mips_epilogue_uses", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "RETURN_ADDR_REGNUM", ")", "return", "true", ";", "if", "(", "TARGET_USE_GOT", "&&", "(", "regno", ")", "==", "GOT_VERSION_REGNUM", ")", "return", "true", ";", "if", "(", "cfun", "->", "machine", "->", "interrupt_handler_p", "&&", "mips_interrupt_extra_call_saved_reg_p", "(", "regno", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "EPILOGUE_USES", "." ]

[ "mips" ]

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "bool", "FP", "=", "TFI", "->", "hasFP", "(", "MF", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ",", "false", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FI: \"", "<<", "FrameIndex", "<<", "\" Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Corrected Offset \"", "<<", "Offset", "<<", "\" for stack size: \"", "<<", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Offset", ">", "Alpha", "::", "IMM_HIGH", "||", "Offset", "<", "Alpha", "::", "IMM_LOW", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Unconditionally using R28 for evil purposes Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "Alpha", "::", "R28", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "getLower16", "(", "Offset", ")", ")", ";", "MachineInstr", "*", "nMI", "=", "BuildMI", "(", "MF", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R28", ")", ".", "addImm", "(", "getUpper16", "(", "Offset", ")", ")", ".", "addReg", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ")", ";", "MBB", ".", "insert", "(", "II", ",", "nMI", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "Alpha", "Alpha", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "Alpha::R15", "Alpha::R30", "\"FI: \"", "\" Offset: \"", "\"\\n\"", "\"Corrected Offset \"", "\" for stack size: \"", "\"\\n\"", "Alpha::IMM_HIGH", "Alpha::IMM_LOW", "\"Unconditionally using R28 for evil purposes Offset: \"", "\"\\n\"", "1", "Alpha::R28", "Alpha::LDAH", "Alpha::R28", "Alpha::R15", "Alpha::R30" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "SIInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "new", "GCNHazardRecognizer", "(", "MF", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isExtractSubvectorCheap", "(", "EVT", "ResVT", ",", "unsigned", "Index", ")", "const", "{", "if", "(", "!", "isOperationLegalOrCustom", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "ResVT", ")", ")", "return", "false", ";", "return", "(", "Index", "==", "0", "||", "Index", "==", "ResVT", ".", "getVectorNumElements", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "EXTRACT_SUBVECTOR", "is", "cheap", "for", "this", "result", "type", "with", "this", "index", "." ]

[ "X86", "X86", "ISD::EXTRACT_SUBVECTOR", "0" ]

[]

[ "<s>", "void", "tilepro_expand_movmisalign", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", ";", "if", "(", "register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "tmp", "=", "operands", "[", "0", "]", ";", "else", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "tilepro_expand_unaligned_load", "(", "tmp", ",", "operands", "[", "1", "]", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ",", "true", ")", ";", "if", "(", "tmp", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "tmp", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "tilepro_expand_unaligned_store", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "the", "movmisalign", "patterns", ".", "One", "of", "the", "operands", "is", "a", "memory", "that", "is", "not", "naturally", "aligned", ".", "Emit", "instructions", "to", "load", "it", "." ]

[ "tilepro", "1", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "AGC" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "{", "return", "false", ";", "}", "const", "MCS51Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "MCS51Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "EntryMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "EntryMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "Register", "SPCopy", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "MCS51", "::", "DREGSRegClass", ")", ";", "BuildMI", "(", "EntryMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MCS51", "::", "COPY", ")", ",", "SPCopy", ")", ".", "addReg", "(", "MCS51", "::", "SP", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "if", "(", "!", "MBB", ".", "empty", "(", ")", "&&", "MBB", ".", "back", "(", ")", ".", "isReturn", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MCS51", "::", "COPY", ")", ",", "MCS51", "::", "SP", ")", ".", "addReg", "(", "SPCopy", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51::DREGSRegClass", "MCS51::COPY", "MCS51::SP", "MCS51::COPY", "MCS51::SP" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "unsigned", "ExtraCondLat", "=", "Cond", ".", "size", "(", ")", "!=", "1", ";", "if", "(", "AArch64", "::", "GPR64allRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "GPR32allRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "1", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "1", ";", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "TrueReg", ")", ")", "TrueCycles", "=", "0", ";", "else", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "FalseReg", ")", ")", "FalseCycles", "=", "0", ";", "return", "true", ";", "}", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "5", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "AArch64", "AArch64", "1", "AArch64::GPR64allRegClass", "AArch64::GPR32allRegClass", "1", "1", "0", "0", "AArch64::FPR64RegClass", "AArch64::FPR32RegClass", "5", "2" ]

[]

[ "<s>", "void", "rs6000_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", ")", "{", "HOST_WIDE_INT", "words", ",", "n_gpr", ",", "n_fpr", ";", "tree", "f_gpr", ",", "f_fpr", ",", "f_res", ",", "f_ovf", ",", "f_sav", ";", "tree", "gpr", ",", "fpr", ",", "ovf", ",", "sav", ",", "t", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_V4", ")", "{", "std_expand_builtin_va_start", "(", "valist", ",", "nextarg", ")", ";", "return", ";", "}", "f_gpr", "=", "TYPE_FIELDS", "(", "TREE_TYPE", "(", "va_list_type_node", ")", ")", ";", "f_fpr", "=", "TREE_CHAIN", "(", "f_gpr", ")", ";", "f_res", "=", "TREE_CHAIN", "(", "f_fpr", ")", ";", "f_ovf", "=", "TREE_CHAIN", "(", "f_res", ")", ";", "f_sav", "=", "TREE_CHAIN", "(", "f_ovf", ")", ";", "valist", "=", "build_va_arg_indirect_ref", "(", "valist", ")", ";", "gpr", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_gpr", ")", ",", "valist", ",", "f_gpr", ",", "NULL_TREE", ")", ";", "fpr", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_fpr", ")", ",", "valist", ",", "f_fpr", ",", "NULL_TREE", ")", ";", "ovf", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_ovf", ")", ",", "valist", ",", "f_ovf", ",", "NULL_TREE", ")", ";", "sav", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_sav", ")", ",", "valist", ",", "f_sav", ",", "NULL_TREE", ")", ";", "words", "=", "current_function_args_info", ".", "words", ";", "n_gpr", "=", "MIN", "(", "current_function_args_info", ".", "sysv_gregno", "-", "GP_ARG_MIN_REG", ",", "GP_ARG_NUM_REG", ")", ";", "n_fpr", "=", "MIN", "(", "current_function_args_info", ".", "fregno", "-", "FP_ARG_MIN_REG", ",", "FP_ARG_NUM_REG", ")", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"va_start: words = \"", "HOST_WIDE_INT_PRINT_DEC", "\", n_gpr = \"", "HOST_WIDE_INT_PRINT_DEC", "\", n_fpr = \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "words", ",", "n_gpr", ",", "n_fpr", ")", ";", "if", "(", "cfun", "->", "va_list_gpr_size", ")", "{", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "gpr", ")", ",", "gpr", ",", "build_int_cst", "(", "NULL_TREE", ",", "n_gpr", ")", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "if", "(", "cfun", "->", "va_list_fpr_size", ")", "{", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "fpr", ")", ",", "fpr", ",", "build_int_cst", "(", "NULL_TREE", ",", "n_fpr", ")", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ovf", ")", ",", "virtual_incoming_args_rtx", ")", ";", "if", "(", "words", "!=", "0", ")", "t", "=", "build", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "ovf", ")", ",", "t", ",", "build_int_cst", "(", "NULL_TREE", ",", "words", "*", "UNITS_PER_WORD", ")", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "ovf", ")", ",", "ovf", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "cfun", "->", "va_list_gpr_size", "&&", "!", "cfun", "->", "va_list_fpr_size", "&&", "n_gpr", "<", "GP_ARG_NUM_REG", "&&", "n_fpr", "<", "FP_ARG_V4_MAX_REG", ")", "return", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "sav", ")", ",", "virtual_stack_vars_rtx", ")", ";", "if", "(", "cfun", "->", "machine", "->", "varargs_save_offset", ")", "t", "=", "build", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "sav", ")", ",", "t", ",", "build_int_cst", "(", "NULL_TREE", ",", "cfun", "->", "machine", "->", "varargs_save_offset", ")", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "sav", ")", ",", "sav", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "</s>" ]

[ "Implement", "va_start", "." ]

[ "rs6000", "\"va_start: words = \"", "\", n_gpr = \"", "\", n_fpr = \"", "\"\\n\"", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "iterator", "begin", "(", ")", "{", "return", "(", "Packet", ".", "begin", "(", ")", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "aarch64_emit_binop", "(", "rtx", "dest", ",", "optab", "binoptab", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "tmp", "=", "expand_binop", "(", "GET_MODE", "(", "dest", ")", ",", "binoptab", ",", "op0", ",", "op1", ",", "dest", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "dest", "!=", "tmp", ")", "emit_move_insn", "(", "dest", ",", "tmp", ")", ";", "}", "</s>" ]

[ "Apply", "BINOPTAB", "to", "OP0", "and", "OP1", "and", "store", "the", "result", "in", "DEST", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCVISD", "::", "SplitF64", ":", "{", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", "->", "getOpcode", "(", ")", "!=", "RISCVISD", "::", "BuildPairF64", ")", "break", ";", "return", "DCI", ".", "CombineTo", "(", "N", ",", "Op0", ".", "getOperand", "(", "0", ")", ",", "Op0", ".", "getOperand", "(", "1", ")", ")", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "RISCV", "RISCV", "RISCVISD::SplitF64", "0", "RISCVISD::BuildPairF64", "0", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", "continue", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "if", "(", "isALU", "(", "I", ")", ")", "I", "=", "MakeALUClause", "(", "MBB", ",", "I", ")", ";", "else", "++", "I", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "ARM", "::", "GPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tcGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "rGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "GPRnopcRegClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "DestReg", ",", "&", "ARM", "::", "GPRPair_with_gsub_1_in_rGPRRegClass", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_0", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_1", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::tGPRRegClass", "ARM::tcGPRRegClass", "ARM::rGPRRegClass", "ARM::GPRnopcRegClass", "ARM::t2LDRi12", "0", "ARM::GPRPairRegClass", "ARM::GPRPair_with_gsub_1_in_rGPRRegClass", "ARM::t2LDRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "ARM" ]

[]

[ "<s>", "static", "rtx", "nvptx_function_incoming_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", "||", "!", "arg", ".", "named", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_UNSPEC", "(", "arg", ".", "mode", ",", "gen_rtvec", "(", "1", ",", "GEN_INT", "(", "cum", "->", "count", ")", ")", ",", "UNSPEC_ARG_REG", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_INCOMING_ARG", "." ]

[ "nvptx", "1" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "const", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "Register", "ValVReg", "=", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "LocInfo", "::", "FPExt", "?", "extendRegister", "(", "Arg", ".", "Regs", "[", "0", "]", ",", "VA", ")", ":", "Arg", ".", "Regs", "[", "0", "]", ";", "const", "LLT", "RegTy", "=", "MRI", ".", "getType", "(", "ValVReg", ")", ";", "if", "(", "RegTy", ".", "getSizeInBytes", "(", ")", ">", "Size", ")", "Size", "=", "RegTy", ".", "getSizeInBytes", "(", ")", ";", "assignValueToAddress", "(", "ValVReg", ",", "Addr", ",", "Size", ",", "MPO", ",", "VA", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "AMDGPU", "0", "0" ]

[]

[ "<s>", "const", "RegisterBank", "&", "MipsRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "using", "namespace", "Mips", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "Mips", "::", "GPR32RegClassID", ":", "case", "Mips", "::", "CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "case", "Mips", "::", "GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "return", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips::GPR32RegClassID", "Mips::CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::GPRBRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "Subtarget", "->", "isTargetDarwin", "(", ")", "?", "LowerGlobalAddressDarwin", "(", "Op", ",", "DAG", ")", ":", "LowerGlobalAddressELF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "VarArgsFrameIndex", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "break", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BIT_CONVERT", ":", "return", "ExpandBIT_CONVERT", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "LowerShift", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "return", "LowerCTTZ", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VSETCC", ":", "return", "LowerVSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Don't know how to custom lower this!\"", "ISD::ConstantPool", "ISD::BlockAddress", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::SELECT_CC", "ISD::BR_CC", "ISD::BR_JT", "ISD::DYNAMIC_STACKALLOC", "ISD::VASTART", "ISD::MEMBARRIER", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::FCOPYSIGN", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GLOBAL_OFFSET_TABLE", "ISD::INTRINSIC_WO_CHAIN", "ISD::BIT_CONVERT", "ISD::SHL", "ISD::SRL", "ISD::SRA", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::SRA_PARTS", "ISD::CTTZ", "ISD::VSETCC", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::EXTRACT_VECTOR_ELT", "ISD::CONCAT_VECTORS" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getMatchingSuperRegClass", "(", "const", "TargetRegisterClass", "*", "A", ",", "const", "TargetRegisterClass", "*", "B", ",", "unsigned", "SubIdx", ")", "const", "{", "if", "(", "!", "Is64Bit", "&&", "SubIdx", "==", "X86", "::", "sub_8bit", ")", "{", "A", "=", "X86GenRegisterInfo", "::", "getSubClassWithSubReg", "(", "A", ",", "X86", "::", "sub_8bit_hi", ")", ";", "if", "(", "!", "A", ")", "return", "0", ";", "}", "return", "X86GenRegisterInfo", "::", "getMatchingSuperRegClass", "(", "A", ",", "B", ",", "SubIdx", ")", ";", "}", "</s>" ]

[ "getMatchingSuperRegClass", "-", "Return", "a", "subclass", "of", "the", "specified", "register", "class", "A", "so", "that", "each", "register", "in", "it", "has", "a", "sub-register", "of", "the", "specified", "sub-register", "index", "which", "is", "in", "the", "specified", "register", "class", "B", "." ]

[ "X86", "X86", "X86::sub_8bit", "X86", "X86::sub_8bit_hi", "0", "X86" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "AArch64TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'x'", ":", "case", "'w'", ":", "if", "(", "type", "->", "isFloatingPointTy", "(", ")", "||", "type", "->", "isVectorTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'z'", ":", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'U'", ":", "if", "(", "constraint", "[", "1", "]", "==", "'p'", "&&", "(", "constraint", "[", "2", "]", "==", "'l'", "||", "constraint", "[", "2", "]", "==", "'a'", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "AArch64", "AArch64", "1", "2", "2" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n[DelaySlotFiller] \"", "<<", "F", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "fillDelaySlots", "(", "*", "FI", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "insertNOPs", "(", "*", "FI", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Patmos", "\"\\n[DelaySlotFiller] \"", "\"\\n\"" ]

[]

[ "<s>", "const", "SystemZInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "uint64_t", "SystemZInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "INLINEASM", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "return", "MI", "->", "getDesc", "(", ")", ".", "getSize", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "SystemZ", "SystemZ", "0" ]

[]

[ "<s>", "Register", "MipsRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MipsSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "bool", "IsN64", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ".", "getABI", "(", ")", ".", "IsN64", "(", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "Mips", "::", "S0", ":", "Mips", "::", "SP", ";", "else", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "(", "IsN64", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ")", ":", "(", "IsN64", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::S0", "Mips::SP", "Mips::FP_64", "Mips::FP", "Mips::SP_64", "Mips::SP" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "isCallerPreservedPhysReg", "(", "unsigned", "PhysReg", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "assert", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "PhysReg", ")", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "if", "(", "PhysReg", "==", "PPC", "::", "X2", ")", "return", "(", "getReservedRegs", "(", "MF", ")", ".", "test", "(", "PPC", "::", "X2", ")", ")", ";", "if", "(", "StackPtrConst", "&&", "(", "PhysReg", "==", "PPC", "::", "X1", ")", "&&", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", ".", "hasOpaqueSPAdjustment", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Physical", "registers", "that", "may", "be", "modified", "within", "a", "function", "but", "are", "guaranteed", "to", "be", "restored", "before", "any", "uses", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::X2", "PPC::X2", "PPC::X1" ]

[]

[ "<s>", "bool", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "return", "LowerRISCVMachineOperandToMCOperand", "(", "MO", ",", "MCOp", ",", "*", "this", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "const", "MCRegisterInfo", "*", "getRegInfo", "(", ")", "const", "{", "return", "RegInfo", ";", "}", "</s>" ]

[ "getRegInfo", "-", "Return", "information", "about", "the", "registers", "currently", "in", "use", "." ]

[ "Mips" ]

[]

[ "<s>", "enum", "reg_class", "mcore_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "rclass", ")", "{", "if", "(", "reg_class_subset_p", "(", "LRW_REGS", ",", "rclass", ")", "&&", "!", "mcore_r15_operand_p", "(", "x", ")", ")", "return", "LRW_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Return", "the", "reg_class", "to", "use", "when", "reloading", "the", "rtx", "X", "into", "the", "class", "CLASS", ".", "If", "X", "is", "too", "complex", "to", "move", "directly", "into", "r15", ",", "prefer", "to", "use", "LRW_REGS", "instead", "." ]

[ "mcore" ]

[]

[ "<s>", "bool", "dominates", "(", "const", "Waitcnt", "&", "Other", ")", "const", "{", "return", "VmCnt", "<=", "Other", ".", "VmCnt", "&&", "ExpCnt", "<=", "Other", ".", "ExpCnt", "&&", "LgkmCnt", "<=", "Other", ".", "LgkmCnt", "&&", "VsCnt", "<=", "Other", ".", "VsCnt", ";", "}", "</s>" ]

[ "Returns", "true", "if", "B1", "occurs", "before", "B2", "in", "the", "trace", ",", "or", "if", "it", "is", "the", "same", "block", "as", "B2", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "mips_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "imode", "=", "GET_MODE_INNER", "(", "vmode", ")", ";", "unsigned", "i", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "unsigned", "nvar", "=", "0", ",", "one_var", "=", "-", "1u", ";", "bool", "all_same", "=", "true", ";", "rtx", "x", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "mips_constant_elt_p", "(", "x", ")", ")", "nvar", "++", ",", "one_var", "=", "i", ";", "if", "(", "i", ">", "0", "&&", "!", "rtx_equal_p", "(", "x", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "}", "if", "(", "nvar", "==", "0", ")", "{", "emit_move_insn", "(", "target", ",", "gen_rtx_CONST_VECTOR", "(", "vmode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ")", ";", "return", ";", "}", "if", "(", "nelt", "==", "2", ")", "{", "rtx", "op0", "=", "force_reg", "(", "imode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "rtx", "op1", "=", "force_reg", "(", "imode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "1", ")", ")", ";", "x", "=", "gen_rtx_VEC_CONCAT", "(", "vmode", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "x", ")", ")", ";", "return", ";", "}", "gcc_assert", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_LOONGSON_VECTORS", ")", ";", "if", "(", "all_same", ")", "{", "mips_expand_vi_broadcast", "(", "vmode", ",", "target", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "return", ";", "}", "if", "(", "nvar", "==", "1", "&&", "vmode", "==", "V4HImode", ")", "{", "mips_expand_vi_loongson_one_pinsrh", "(", "target", ",", "vals", ",", "one_var", ")", ";", "return", ";", "}", "mips_expand_vi_general", "(", "vmode", ",", "imode", ",", "nelt", ",", "nvar", ",", "target", ",", "vals", ")", ";", "}", "</s>" ]

[ "Expand", "a", "vector", "initialization", "." ]

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

[]

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

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

[ "TPC", "TPC", "TPC::SRFRegClass" ]

[]

[ "<s>", "bool", "WebAssemblyPeephole", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Store Results **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "auto", "&", "LibInfo", "=", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "{", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "unsigned", "OldReg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "NewReg", "=", "MI", ".", "getOperand", "(", "WebAssembly", "::", "StoreValueOperandNo", ")", ".", "getReg", "(", ")", ";", "Changed", "|=", "MaybeRewriteToDiscard", "(", "OldReg", ",", "NewReg", ",", "MO", ",", "MFI", ",", "MRI", ")", ";", "break", ";", "}", "case", "WebAssembly", "::", "CALL_I32", ":", "case", "WebAssembly", "::", "CALL_I64", ":", "{", "MachineOperand", "&", "Op1", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "Op1", ".", "isSymbol", "(", ")", ")", "{", "StringRef", "Name", "(", "Op1", ".", "getSymbolName", "(", ")", ")", ";", "if", "(", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMCPY", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMMOVE", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ")", "{", "LibFunc", "::", "Func", "Func", ";", "if", "(", "LibInfo", ".", "getLibFunc", "(", "Name", ",", "Func", ")", ")", "{", "const", "auto", "&", "Op2", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "Op2", ".", "isReg", "(", ")", ")", "report_fatal_error", "(", "\"Peephole: call to builtin function with \"", "\"wrong signature, not consuming reg\"", ")", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "unsigned", "OldReg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "NewReg", "=", "Op2", ".", "getReg", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "NewReg", ")", "&&", "(", "MRI", ".", "getRegClass", "(", "NewReg", ")", "!=", "MRI", ".", "getRegClass", "(", "OldReg", ")", ")", ")", "report_fatal_error", "(", "\"Peephole: call to builtin function with \"", "\"wrong signature, from/to mismatch\"", ")", ";", "Changed", "|=", "MaybeRewriteToDiscard", "(", "OldReg", ",", "NewReg", ",", "MO", ",", "MFI", ",", "MRI", ")", ";", "}", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Store Results **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly::STORE8_I32", "WebAssembly::STORE16_I32", "WebAssembly::STORE8_I64", "WebAssembly::STORE16_I64", "WebAssembly::STORE32_I64", "WebAssembly::STORE_F32", "WebAssembly::STORE_F64", "WebAssembly::STORE_I32", "WebAssembly::STORE_I64", "0", "WebAssembly::StoreValueOperandNo", "WebAssembly::CALL_I32", "WebAssembly::CALL_I64", "1", "2", "\"Peephole: call to builtin function with \"", "\"wrong signature, not consuming reg\"", "0", "\"Peephole: call to builtin function with \"", "\"wrong signature, from/to mismatch\"" ]

[]

[ "<s>", "bool", "AMDGPUSubtarget", "::", "makeLIDRangeMetadata", "(", "Instruction", "*", "I", ")", "const", "{", "Function", "*", "Kernel", "=", "I", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "MinSize", "=", "0", ";", "unsigned", "MaxSize", "=", "getFlatWorkGroupSizes", "(", "*", "Kernel", ")", ".", "second", ";", "bool", "IdQuery", "=", "false", ";", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ")", "{", "const", "Function", "*", "F", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "F", ")", "{", "unsigned", "Dim", "=", "UINT_MAX", ";", "switch", "(", "F", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_workitem_id_x", ":", "case", "Intrinsic", "::", "r600_read_tidig_x", ":", "IdQuery", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Intrinsic", "::", "r600_read_local_size_x", ":", "Dim", "=", "0", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_workitem_id_y", ":", "case", "Intrinsic", "::", "r600_read_tidig_y", ":", "IdQuery", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Intrinsic", "::", "r600_read_local_size_y", ":", "Dim", "=", "1", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_workitem_id_z", ":", "case", "Intrinsic", "::", "r600_read_tidig_z", ":", "IdQuery", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Intrinsic", "::", "r600_read_local_size_z", ":", "Dim", "=", "2", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "Dim", "<=", "3", ")", "{", "if", "(", "auto", "Node", "=", "Kernel", "->", "getMetadata", "(", "\"reqd_work_group_size\"", ")", ")", "if", "(", "Node", "->", "getNumOperands", "(", ")", "==", "3", ")", "MinSize", "=", "MaxSize", "=", "mdconst", "::", "extract", "<", "ConstantInt", ">", "(", "Node", "->", "getOperand", "(", "Dim", ")", ")", "->", "getZExtValue", "(", ")", ";", "}", "}", "}", "if", "(", "!", "MaxSize", ")", "return", "false", ";", "if", "(", "IdQuery", ")", "MinSize", "=", "0", ";", "else", "++", "MaxSize", ";", "MDBuilder", "MDB", "(", "I", "->", "getContext", "(", ")", ")", ";", "MDNode", "*", "MaxWorkGroupSizeRange", "=", "MDB", ".", "createRange", "(", "APInt", "(", "32", ",", "MinSize", ")", ",", "APInt", "(", "32", ",", "MaxSize", ")", ")", ";", "I", "->", "setMetadata", "(", "LLVMContext", "::", "MD_range", ",", "MaxWorkGroupSizeRange", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Creates", "value", "range", "metadata", "on", "an", "workitemid", ".", "*", "intrinsic", "call", "or", "load", "." ]

[ "AMDGPU", "AMDGPU", "0", "Intrinsic::amdgcn_workitem_id_x", "Intrinsic::r600_read_tidig_x", "Intrinsic::r600_read_local_size_x", "0", "Intrinsic::amdgcn_workitem_id_y", "Intrinsic::r600_read_tidig_y", "Intrinsic::r600_read_local_size_y", "1", "Intrinsic::amdgcn_workitem_id_z", "Intrinsic::r600_read_tidig_z", "Intrinsic::r600_read_local_size_z", "2", "3", "\"reqd_work_group_size\"", "3", "0", "32", "32" ]

[]

[ "<s>", "void", "GCNMaxOccupancySchedStrategy", "::", "pickNodeFromQueue", "(", "SchedBoundary", "&", "Zone", ",", "const", "CandPolicy", "&", "ZonePolicy", ",", "const", "RegPressureTracker", "&", "RPTracker", ",", "SchedCandidate", "&", "Cand", ")", "{", "const", "SIRegisterInfo", "*", "SRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "TRI", ")", ";", "ArrayRef", "<", "unsigned", ">", "Pressure", "=", "RPTracker", ".", "getRegSetPressureAtPos", "(", ")", ";", "unsigned", "SGPRPressure", "=", "Pressure", "[", "AMDGPU", "::", "RegisterPressureSets", "::", "SReg_32", "]", ";", "unsigned", "VGPRPressure", "=", "Pressure", "[", "AMDGPU", "::", "RegisterPressureSets", "::", "VGPR_32", "]", ";", "ReadyQueue", "&", "Q", "=", "Zone", ".", "Available", ";", "for", "(", "SUnit", "*", "SU", ":", "Q", ")", "{", "SchedCandidate", "TryCand", "(", "ZonePolicy", ")", ";", "initCandidate", "(", "TryCand", ",", "SU", ",", "Zone", ".", "isTop", "(", ")", ",", "RPTracker", ",", "SRI", ",", "SGPRPressure", ",", "VGPRPressure", ")", ";", "SchedBoundary", "*", "ZoneArg", "=", "Cand", ".", "AtTop", "==", "TryCand", ".", "AtTop", "?", "&", "Zone", ":", "nullptr", ";", "GenericScheduler", "::", "tryCandidate", "(", "Cand", ",", "TryCand", ",", "ZoneArg", ")", ";", "if", "(", "TryCand", ".", "Reason", "!=", "NoCand", ")", "{", "if", "(", "TryCand", ".", "ResDelta", "==", "SchedResourceDelta", "(", ")", ")", "TryCand", ".", "initResourceDelta", "(", "Zone", ".", "DAG", ",", "SchedModel", ")", ";", "Cand", ".", "setBest", "(", "TryCand", ")", ";", "LLVM_DEBUG", "(", "traceCandidate", "(", "Cand", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Pick", "the", "best", "candidate", "from", "the", "queue", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::RegisterPressureSets", "AMDGPU::RegisterPressureSets" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "SlotSize", "=", "STI", ".", "is64Bit", "(", ")", "?", "8", ":", "4", ";", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "CalleeFrameSize", "=", "0", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "CalleeFrameSize", "+=", "SlotSize", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "8", "4", "0", "X86", "X86", "X86", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "X86", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "bool", "RISCVCoreVHwlpBlocks", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "hasExtXCoreVHwlp", "(", ")", ")", "{", "return", "false", ";", "}", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "ML", ":", "MLI", ")", "{", "Changed", "|=", "ProcessLoop", "(", "ML", ",", "MF", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "static", "int", "arm_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "elements", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "return", "current_tune", "->", "vec_costs", "->", "scalar_stmt_cost", ";", "case", "scalar_load", ":", "return", "current_tune", "->", "vec_costs", "->", "scalar_load_cost", ";", "case", "scalar_store", ":", "return", "current_tune", "->", "vec_costs", "->", "scalar_store_cost", ";", "case", "vector_stmt", ":", "return", "current_tune", "->", "vec_costs", "->", "vec_stmt_cost", ";", "case", "vector_load", ":", "return", "current_tune", "->", "vec_costs", "->", "vec_align_load_cost", ";", "case", "vector_store", ":", "return", "current_tune", "->", "vec_costs", "->", "vec_store_cost", ";", "case", "vec_to_scalar", ":", "return", "current_tune", "->", "vec_costs", "->", "vec_to_scalar_cost", ";", "case", "scalar_to_vec", ":", "return", "current_tune", "->", "vec_costs", "->", "scalar_to_vec_cost", ";", "case", "unaligned_load", ":", "return", "current_tune", "->", "vec_costs", "->", "vec_unalign_load_cost", ";", "case", "unaligned_store", ":", "return", "current_tune", "->", "vec_costs", "->", "vec_unalign_store_cost", ";", "case", "cond_branch_taken", ":", "return", "current_tune", "->", "vec_costs", "->", "cond_taken_branch_cost", ";", "case", "cond_branch_not_taken", ":", "return", "current_tune", "->", "vec_costs", "->", "cond_not_taken_branch_cost", ";", "case", "vec_perm", ":", "case", "vec_promote_demote", ":", "return", "current_tune", "->", "vec_costs", "->", "vec_stmt_cost", ";", "case", "vec_construct", ":", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "return", "elements", "/", "2", "+", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "aarch64_expand_prologue", "(", "void", ")", "{", "aarch64_layout_frame", "(", ")", ";", "poly_int64", "frame_size", "=", "cfun", "->", "machine", "->", "frame", ".", "frame_size", ";", "poly_int64", "initial_adjust", "=", "cfun", "->", "machine", "->", "frame", ".", "initial_adjust", ";", "HOST_WIDE_INT", "callee_adjust", "=", "cfun", "->", "machine", "->", "frame", ".", "callee_adjust", ";", "poly_int64", "final_adjust", "=", "cfun", "->", "machine", "->", "frame", ".", "final_adjust", ";", "poly_int64", "callee_offset", "=", "cfun", "->", "machine", "->", "frame", ".", "callee_offset", ";", "unsigned", "reg1", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", ";", "unsigned", "reg2", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ";", "bool", "emit_frame_chain", "=", "cfun", "->", "machine", "->", "frame", ".", "emit_frame_chain", ";", "rtx_insn", "*", "insn", ";", "if", "(", "aarch64_return_address_signing_enabled", "(", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_pacisp", "(", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_TOGGLE_RA_MANGLE", ",", "const0_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "constant_lower_bound", "(", "frame_size", ")", ";", "if", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "calls_alloca", ")", "{", "if", "(", "maybe_gt", "(", "frame_size", ",", "PROBE_INTERVAL", ")", "&&", "maybe_gt", "(", "frame_size", ",", "get_stack_check_protect", "(", ")", ")", ")", "aarch64_emit_probe_stack_range", "(", "get_stack_check_protect", "(", ")", ",", "(", "frame_size", "-", "get_stack_check_protect", "(", ")", ")", ")", ";", "}", "else", "if", "(", "maybe_gt", "(", "frame_size", ",", "0", ")", ")", "aarch64_emit_probe_stack_range", "(", "get_stack_check_protect", "(", ")", ",", "frame_size", ")", ";", "}", "rtx", "ip0_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP0_REGNUM", ")", ";", "rtx", "ip1_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP1_REGNUM", ")", ";", "aarch64_sub_sp", "(", "ip0_rtx", ",", "ip1_rtx", ",", "initial_adjust", ",", "true", ")", ";", "if", "(", "callee_adjust", "!=", "0", ")", "aarch64_push_regs", "(", "reg1", ",", "reg2", ",", "callee_adjust", ")", ";", "if", "(", "emit_frame_chain", ")", "{", "poly_int64", "reg_offset", "=", "callee_adjust", ";", "if", "(", "callee_adjust", "==", "0", ")", "{", "reg1", "=", "R29_REGNUM", ";", "reg2", "=", "R30_REGNUM", ";", "reg_offset", "=", "callee_offset", ";", "aarch64_save_callee_saves", "(", "DImode", ",", "reg_offset", ",", "reg1", ",", "reg2", ",", "false", ")", ";", "}", "aarch64_add_offset", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "callee_offset", ",", "ip1_rtx", ",", "ip0_rtx", ",", "frame_pointer_needed", ")", ";", "if", "(", "frame_pointer_needed", "&&", "!", "frame_size", ".", "is_constant", "(", ")", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "gcc_assert", "(", "RTX_FRAME_RELATED_P", "(", "insn", ")", ")", ";", "if", "(", "!", "find_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "NULL_RTX", ")", ")", "{", "rtx", "src", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "callee_offset", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "hard_frame_pointer_rtx", ",", "src", ")", ")", ";", "}", "reg_offset", "-=", "callee_offset", ";", "aarch64_add_cfa_expression", "(", "insn", ",", "reg2", ",", "hard_frame_pointer_rtx", ",", "reg_offset", "+", "UNITS_PER_WORD", ")", ";", "aarch64_add_cfa_expression", "(", "insn", ",", "reg1", ",", "hard_frame_pointer_rtx", ",", "reg_offset", ")", ";", "}", "emit_insn", "(", "gen_stack_tie", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "}", "aarch64_save_callee_saves", "(", "DImode", ",", "callee_offset", ",", "R0_REGNUM", ",", "R30_REGNUM", ",", "callee_adjust", "!=", "0", "||", "emit_frame_chain", ")", ";", "aarch64_save_callee_saves", "(", "DFmode", ",", "callee_offset", ",", "V0_REGNUM", ",", "V31_REGNUM", ",", "callee_adjust", "!=", "0", "||", "emit_frame_chain", ")", ";", "aarch64_sub_sp", "(", "ip1_rtx", ",", "ip0_rtx", ",", "final_adjust", ",", "!", "frame_pointer_needed", ")", ";", "}", "</s>" ]

[ "Generate", "the", "prologue", "instructions", "for", "entry", "into", "a", "function", ".", "Establish", "the", "stack", "frame", "by", "decreasing", "the", "stack", "pointer", "with", "a", "properly", "calculated", "size", "and", ",", "if", "necessary", ",", "create", "a", "frame", "record", "filled", "with", "the", "values", "of", "LR", "and", "previous", "frame", "pointer", ".", "The", "current", "FP", "is", "also", "set", "up", "if", "it", "is", "in", "use", "." ]

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

[]

[ "<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", "(", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "void", "CSKYFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "unsigned", "getBranchTargetOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "Op", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "ARM", "0" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "ARMOperand", ">", "CreateMem", "(", "unsigned", "BaseRegNum", ",", "const", "MCExpr", "*", "OffsetImm", ",", "unsigned", "OffsetRegNum", ",", "ARM_AM", "::", "ShiftOpc", "ShiftType", ",", "unsigned", "ShiftImm", ",", "unsigned", "Alignment", ",", "bool", "isNegative", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "SMLoc", "AlignmentLoc", "=", "SMLoc", "(", ")", ")", "{", "auto", "Op", "=", "std", "::", "make_unique", "<", "ARMOperand", ">", "(", "k_Memory", ")", ";", "Op", "->", "Memory", ".", "BaseRegNum", "=", "BaseRegNum", ";", "Op", "->", "Memory", ".", "OffsetImm", "=", "OffsetImm", ";", "Op", "->", "Memory", ".", "OffsetRegNum", "=", "OffsetRegNum", ";", "Op", "->", "Memory", ".", "ShiftType", "=", "ShiftType", ";", "Op", "->", "Memory", ".", "ShiftImm", "=", "ShiftImm", ";", "Op", "->", "Memory", ".", "Alignment", "=", "Alignment", ";", "Op", "->", "Memory", ".", "isNegative", "=", "isNegative", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "Op", "->", "AlignmentLoc", "=", "AlignmentLoc", ";", "return", "Op", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "ARM", "ARM", "ARM_AM::ShiftOpc", "ARM" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isFNegFree", "(", "EVT", "VT", ")", "const", "{", "return", "isFAbsFree", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fneg", "operation", "is", "free", "to", "the", "point", "where", "it", "is", "never", "worthwhile", "to", "replace", "it", "with", "a", "bitwise", "operation", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SIC DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SILowerControlFlowPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "HaveKill", "=", "false", ";", "bool", "NeedM0", "=", "false", ";", "bool", "NeedWQM", "=", "false", ";", "unsigned", "Depth", "=", "0", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "TII", "->", "isDS", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "NeedM0", "=", "true", ";", "NeedWQM", "=", "true", ";", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AMDGPU", "::", "SI_IF", ":", "++", "Depth", ";", "If", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "Else", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_BREAK", ":", "Break", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "IfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE_BREAK", ":", "ElseBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "++", "Depth", ";", "Loop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "if", "(", "--", "Depth", "==", "0", "&&", "HaveKill", ")", "{", "SkipIfDead", "(", "MI", ")", ";", "HaveKill", "=", "false", ";", "}", "EndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_KILL", ":", "if", "(", "Depth", "==", "0", ")", "SkipIfDead", "(", "MI", ")", ";", "else", "HaveKill", "=", "true", ";", "Kill", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "Branch", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_SRC", ":", "IndirectSrc", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V1", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V2", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V4", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V8", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V16", ":", "IndirectDst", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "V_INTERP_P1_F32", ":", "case", "AMDGPU", "::", "V_INTERP_P2_F32", ":", "case", "AMDGPU", "::", "V_INTERP_MOV_F32", ":", "NeedWQM", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "NeedM0", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "InitM0ForLDS", "(", "MBB", ".", "getFirstNonPHI", "(", ")", ")", ";", "}", "if", "(", "NeedWQM", "&&", "MFI", "->", "getShaderType", "(", ")", "==", "ShaderType", "::", "PIXEL", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBB", ".", "getFirstNonPHI", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_WQM_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "SI", "SI", "0", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "0", "SI", "0", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "static", "bool", "microblaze_gen_pic_addr_dif_vec", "(", "void", ")", "{", "return", "(", "flag_pic", "&&", "!", "TARGET_PIC_DATA_TEXT_REL", ")", ";", "}", "</s>" ]

[ "We", "need", "to", "disable", "address", "diff", "vectors", "incase", "of", "pic", "data", "text", "relative", "mode", "." ]

[ "microblaze" ]

[]

[ "<s>", "void", "TOYFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "TOYInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "TOYInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "StackSize", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TOY", "::", "SUBri", ")", ",", "TOY", "::", "SP", ")", ".", "addReg", "(", "TOY", "::", "SP", ")", ".", "addImm", "(", "StackSize", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "TOY", "TOY", "TOY", "TOY", "TOY::SUBri", "TOY::SP", "TOY::SP" ]

[]

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

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

[ "WebAssembly", "WebAssembly", "ISD::BUILTIN_OP_END" ]

[]

[ "<s>", "bool", "X86CmovConverterPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "EnableCmovConverter", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TSchedModel", ".", "init", "(", "&", "STI", ")", ";", "if", "(", "ForceMemOperand", ")", "{", "CmovGroups", "AllCmovGroups", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "4", ">", "Blocks", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Blocks", ".", "push_back", "(", "&", "MBB", ")", ";", "if", "(", "collectCmovCandidates", "(", "Blocks", ",", "AllCmovGroups", ",", "true", ")", ")", "{", "for", "(", "auto", "&", "Group", ":", "AllCmovGroups", ")", "{", "if", "(", "!", "llvm", "::", "any_of", "(", "Group", ",", "[", "&", "]", "(", "MachineInstr", "*", "I", ")", "{", "return", "I", "->", "mayLoad", "(", ")", ";", "}", ")", ")", "continue", ";", "Changed", "=", "true", ";", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "}", "}", "SmallVector", "<", "MachineLoop", "*", ",", "4", ">", "Loops", "(", "MLI", "->", "begin", "(", ")", ",", "MLI", "->", "end", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "(", "int", ")", "Loops", ".", "size", "(", ")", ";", "++", "i", ")", "for", "(", "MachineLoop", "*", "Child", ":", "Loops", "[", "i", "]", "->", "getSubLoops", "(", ")", ")", "Loops", ".", "push_back", "(", "Child", ")", ";", "for", "(", "MachineLoop", "*", "CurrLoop", ":", "Loops", ")", "{", "if", "(", "!", "CurrLoop", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "continue", ";", "CmovGroups", "CmovInstGroups", ";", "if", "(", "!", "collectCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "if", "(", "!", "checkForProfitableCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "Changed", "=", "true", ";", "for", "(", "auto", "&", "Group", ":", "CmovInstGroups", ")", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"********** \"", "\" : \"", "\"**********\\n\"", "4", "4", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU IR late optimizations\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU IR late optimizations\"" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "TargetAlign", "-", "1", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoRedZone", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "(", "Subtarget", ".", "isPPC64", "(", ")", "||", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "FrameSize", "==", "0", ")", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "(", "Subtarget", ".", "isPPC64", "(", ")", "&&", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "spillsCR", "(", "MF", ")", ")", "&&", "(", "!", "ALIGN_STACK", "||", "MaxAlign", "<=", "TargetAlign", ")", ")", "{", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getMinCallFrameSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isDarwinABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

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

[]

[ "<s>", "int", "zap_mask", "(", "HOST_WIDE_INT", "value", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "HOST_BITS_PER_WIDE_INT", "/", "HOST_BITS_PER_CHAR", ";", "i", "++", ",", "value", ">>=", "8", ")", "if", "(", "(", "value", "&", "0xff", ")", "!=", "0", "&&", "(", "value", "&", "0xff", ")", "!=", "0xff", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Returns", "1", "if", "VALUE", "is", "a", "mask", "that", "contains", "full", "bytes", "of", "zero", "or", "ones", "." ]

[ "alpha", "0", "8", "0xff", "0", "0xff", "0xff", "0", "1" ]

[]

[ "<s>", "static", "std", "::", "string", "getGraphName", "(", "const", "ScheduleDAG", "*", "G", ")", "{", "return", "G", "->", "MF", ".", "getName", "(", ")", ".", "str", "(", ")", ";", "}", "</s>" ]

[ "Generate", "a", "title", "for", "the", "graph", "in", "DOT", "format", "." ]

[ "Patmos" ]

[]

[ "<s>", "virtual", "const", "TargetFrameInfo", "*", "getFrameInfo", "(", ")", "const", "{", "return", "&", "FrameInfo", ";", "}", "</s>" ]

[ "getFrameInfo", "-", "Return", "the", "frame", "info", "object", "for", "the", "current", "function", "." ]

[ "Blackfin" ]

[]

[ "<s>", "void", "reset", "(", ")", "{", "Inst2Replace", "=", "nullptr", ";", "BackedgeInst", "=", "nullptr", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "optForSize", "(", ")", ")", "return", ";", "if", "(", "!", "ST", "->", "isThumb2", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "value_op_begin", "(", ")", ",", "I", ".", "value_op_end", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "0", "4", "\"Cost of loop: \"", "\"\\n\"", "4", "60", "12" ]

[]

[ "<s>", "bool", "mips_legitimize_move", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "!", "register_operand", "(", "dest", ",", "mode", ")", "&&", "!", "register_operand", "(", "src", ",", "mode", ")", "&&", "(", "TARGET_MIPS16", "||", "!", "const_0_operand", "(", "src", ",", "mode", ")", "||", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", ")", "{", "mips_emit_move", "(", "dest", ",", "force_reg", "(", "mode", ",", "src", ")", ")", ";", "return", "true", ";", "}", "if", "(", "CONSTANT_P", "(", "src", ")", "&&", "!", "move_operand", "(", "src", ",", "mode", ")", ")", "{", "mips_legitimize_const_move", "(", "mode", ",", "dest", ",", "src", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "src", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "(", "set", "DEST", "SRC", ")", "is", "not", "a", "valid", "instruction", ",", "emit", "an", "equivalent", "sequence", "that", "is", "valid", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreSched2", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "addPass", "(", "createR600EmitClauseMarkers", "(", ")", ")", ";", "if", "(", "ST", ".", "isIfCvtEnabled", "(", ")", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "addPass", "(", "createR600ClauseMergePass", "(", "*", "TM", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "MOSCallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "CallLoweringInfo", "&", "Info", ")", "const", "{", "if", "(", "Info", ".", "IsMustTailCall", ")", "report_fatal_error", "(", "\"Musttail calls not supported.\"", ")", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "IsIndirect", "=", "Info", ".", "Callee", ".", "isReg", "(", ")", ";", "if", "(", "IsIndirect", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "MOS", "::", "RS9", ",", "Info", ".", "Callee", ")", ";", "Info", ".", "Callee", ".", "ChangeToES", "(", "\"__call_indir\"", ")", ";", "}", "auto", "CallSeqStart", "=", "MIRBuilder", ".", "buildInstr", "(", "MOS", "::", "ADJCALLSTACKDOWN", ")", ";", "auto", "Call", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "MOS", "::", "JSR", ")", ".", "add", "(", "Info", ".", "Callee", ")", ".", "addRegMask", "(", "TRI", ".", "getCallPreservedMask", "(", "MF", ",", "Info", ".", "CallConv", ")", ")", ";", "if", "(", "IsIndirect", ")", "Call", ".", "addUse", "(", "MOS", "::", "RS9", ",", "RegState", "::", "Implicit", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "OutArgs", ";", "for", "(", "auto", "&", "OrigArg", ":", "Info", ".", "OrigArgs", ")", "{", "splitToValueTypes", "(", "OrigArg", ",", "OutArgs", ",", "DL", ")", ";", "}", "SmallVector", "<", "ArgInfo", ",", "8", ">", "InArgs", ";", "if", "(", "!", "Info", ".", "OrigRet", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "splitToValueTypes", "(", "Info", ".", "OrigRet", ",", "InArgs", ",", "DL", ")", ";", "MOSOutgoingArgsHandler", "ArgsHandler", "(", "MIRBuilder", ",", "Call", ",", "MRI", ")", ";", "MOSValueAssigner", "ArgsAssigner", "(", "false", ",", "MRI", ",", "MF", ")", ";", "if", "(", "!", "determineAndHandleAssignments", "(", "ArgsHandler", ",", "ArgsAssigner", ",", "OutArgs", ",", "MIRBuilder", ",", "Info", ".", "CallConv", ",", "Info", ".", "IsVarArg", ")", ")", "return", "false", ";", "MIRBuilder", ".", "insertInstr", "(", "Call", ")", ";", "uint64_t", "StackSize", "=", "ArgsAssigner", ".", "StackOffset", ";", "if", "(", "!", "Info", ".", "OrigRet", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "{", "MOSIncomingReturnHandler", "RetHandler", "(", "MIRBuilder", ",", "MRI", ",", "Call", ")", ";", "MOSValueAssigner", "RetAssigner", "(", "true", ",", "MRI", ",", "MF", ")", ";", "if", "(", "!", "determineAndHandleAssignments", "(", "RetHandler", ",", "RetAssigner", ",", "InArgs", ",", "MIRBuilder", ",", "Info", ".", "CallConv", ",", "Info", ".", "IsVarArg", ")", ")", "return", "false", ";", "StackSize", "=", "std", "::", "max", "(", "StackSize", ",", "RetAssigner", ".", "StackOffset", ")", ";", "}", "CallSeqStart", ".", "addImm", "(", "StackSize", ")", ".", "addImm", "(", "0", ")", ";", "MIRBuilder", ".", "buildInstr", "(", "MOS", "::", "ADJCALLSTACKUP", ")", ".", "addImm", "(", "StackSize", ")", ".", "addImm", "(", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "MOS", "MOS", "\"Musttail calls not supported.\"", "MOS::RS9", "\"__call_indir\"", "MOS::ADJCALLSTACKDOWN", "MOS::JSR", "MOS::RS9", "8", "8", "MOS", "MOS", "MOS", "MOS", "0", "MOS::ADJCALLSTACKUP", "0" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_BPF64", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "switch", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "MVT", "::", "i64", ":", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "BPF", "::", "GPRRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "errs", "(", ")", "<<", "\"Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" \"", ";", "MF", ".", "getFunction", "(", ")", "->", "getFunctionType", "(", ")", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"too many function args\"", ")", ";", "}", "}", "if", "(", "isVarArg", "||", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "errs", "(", ")", "<<", "\"Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" \"", ";", "MF", ".", "getFunction", "(", ")", "->", "getFunctionType", "(", ")", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"functions with VarArgs or StructRet are not supported\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "BPF", "BPF", "ISD::InputArg", "\"Unsupported calling convention\"", "16", "BPF", "0", "\"LowerFormalArguments Unhandled argument type: \"", "\"\\n\"", "0", "MVT::i64", "BPF::GPRRegClass", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"Function: \"", "\" \"", "\"\\n\"", "\"too many function args\"", "\"Function: \"", "\" \"", "\"\\n\"", "\"functions with VarArgs or StructRet are not supported\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "Z80RegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", ")", "const", "{", "const", "TargetRegisterClass", "*", "Super", "=", "RC", ";", "TargetRegisterClass", "::", "sc_iterator", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "do", "{", "switch", "(", "Super", "->", "getID", "(", ")", ")", "{", "case", "Z80", "::", "R8RegClassID", ":", "case", "Z80", "::", "R16RegClassID", ":", "case", "Z80", "::", "R24RegClassID", ":", "return", "Super", ";", "}", "Super", "=", "*", "I", "++", ";", "}", "while", "(", "Super", ")", ";", "return", "RC", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "Z80", "Z80", "Z80::R8RegClassID", "Z80::R16RegClassID", "Z80::R24RegClassID" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "ARM64" ]

[]