Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "rtx", "rs6000_address_for_fpconvert", "(", "rtx", "x", ")", "{", "int", "strict_p", "=", "(", "reload_in_progress", "||", "reload_completed", ")", ";", "rtx", "addr", ";", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "!", "legitimate_indirect_address_p", "(", "addr", ",", "strict_p", ")", "&&", "!", "legitimate_indexed_address_p", "(", "addr", ",", "strict_p", ")", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", "{", "rtx", "reg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "HOST_WIDE_INT", "size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ";", "rtx", "size_rtx", "=", "GEN_INT", "(", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", "?", "-", "size", ":", "size", ")", ";", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "reg", ",", "reg", ",", "size_rtx", ")", ")", ";", "addr", "=", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", ")", "{", "rtx", "reg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "expr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "expr", ")", "==", "PLUS", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "reg", ",", "XEXP", "(", "expr", ",", "0", ")", ",", "XEXP", "(", "expr", ",", "1", ")", ")", ")", ";", "addr", "=", "reg", ";", "}", "x", "=", "replace_equiv_address", "(", "x", ",", "copy_addr_to_reg", "(", "addr", ")", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Given", "a", "memory", "reference", ",", "if", "it", "is", "not", "a", "reg", "or", "reg+reg", "addressing", ",", "convert", "to", "such", "a", "form", "to", "deal", "with", "memory", "reference", "instructions", "like", "STFIWX", "that", "only", "take", "reg+reg", "addressing", "." ]

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

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "if", "(", "DisableParallelDSP", ")", "return", "false", ";", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "TLI", "=", "&", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", "F", ")", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "M", "=", "F", ".", "getParent", "(", ")", ";", "DL", "=", "&", "M", "->", "getDataLayout", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "auto", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "allowsUnalignedMem", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unaligned memory access not supported: not \"", "\"running pass ARMParallelDSP\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "ST", "->", "hasDSP", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"DSP extension not enabled: not running pass \"", "\"ARMParallelDSP\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "ST", "->", "isLittle", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Only supporting little endian: not running pass \"", "<<", "\"ARMParallelDSP\\n\"", ")", ";", "return", "false", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n== Parallel DSP pass ==\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" - \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\\n\"", ")", ";", "bool", "Changes", "=", "MatchSMLAD", "(", "F", ")", ";", "return", "Changes", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Unaligned memory access not supported: not \"", "\"running pass ARMParallelDSP\\n\"", "\"DSP extension not enabled: not running pass \"", "\"ARMParallelDSP\\n\"", "\"Only supporting little endian: not running pass \"", "\"ARMParallelDSP\\n\"", "\"\\n== Parallel DSP pass ==\\n\"", "\" - \"", "\"\\n\\n\"" ]

[]

[ "<s>", "SparcTargetMachine", "::", "SparcTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "is64bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "is64bit", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "make_unique", "<", "SparcELFTargetObjectFile", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "is64bit", ")", ",", "is64Bit", "(", "is64bit", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "singlemove_string", "(", "rtx", "*", "operands", ")", "{", "if", "(", "operands", "[", "1", "]", "!=", "const0_rtx", ")", "return", "\"mov\\t%1,%0\"", ";", "return", "\"clr\\t%0\"", ";", "}", "</s>" ]

[ "Return", "the", "best", "assembler", "insn", "template", "for", "moving", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "as", "a", "fullword", "." ]

[ "pdp11", "1", "\"mov\\t%1,%0\"", "\"clr\\t%0\"" ]

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "VideoCore4" ]

[]

[ "<s>", "const", "uint16_t", "*", "XtensaRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_Xtensa_SaveList", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "Xtensa" ]

[]

[ "<s>", "static", "bool", "rs6000_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "unsigned", "from_size", "=", "GET_MODE_SIZE", "(", "from", ")", ";", "unsigned", "to_size", "=", "GET_MODE_SIZE", "(", "to", ")", ";", "if", "(", "from_size", "!=", "to_size", ")", "{", "enum", "reg_class", "xclass", "=", "(", "TARGET_VSX", ")", "?", "VSX_REGS", ":", "FLOAT_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "xclass", ",", "rclass", ")", ")", "{", "unsigned", "to_nregs", "=", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "to", ")", ";", "unsigned", "from_nregs", "=", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "from", ")", ";", "bool", "to_float128_vector_p", "=", "FLOAT128_VECTOR_P", "(", "to", ")", ";", "bool", "from_float128_vector_p", "=", "FLOAT128_VECTOR_P", "(", "from", ")", ";", "if", "(", "to_float128_vector_p", "&&", "from_float128_vector_p", ")", "return", "true", ";", "else", "if", "(", "to_float128_vector_p", "||", "from_float128_vector_p", ")", "return", "false", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", "&&", "(", "to", "==", "TDmode", "||", "from", "==", "TDmode", ")", ")", "return", "false", ";", "if", "(", "(", "to", "==", "DDmode", "&&", "from", "==", "SDmode", ")", "||", "(", "to", "==", "SDmode", "&&", "from", "==", "DDmode", ")", ")", "return", "true", ";", "if", "(", "from_size", "<", "8", "||", "to_size", "<", "8", ")", "return", "false", ";", "if", "(", "from_size", "==", "8", "&&", "(", "8", "*", "to_nregs", ")", "!=", "to_size", ")", "return", "false", ";", "if", "(", "to_size", "==", "8", "&&", "(", "8", "*", "from_nregs", ")", "!=", "from_size", ")", "return", "false", ";", "return", "true", ";", "}", "else", "return", "true", ";", "}", "if", "(", "TARGET_VSX", "&&", "VSX_REG_CLASS_P", "(", "rclass", ")", ")", "{", "unsigned", "num_regs", "=", "(", "from_size", "+", "15", ")", "/", "16", ";", "if", "(", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "to", ")", ">", "num_regs", "||", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "from", ")", ">", "num_regs", ")", "return", "false", ";", "return", "(", "from_size", "==", "8", "||", "from_size", "==", "16", ")", ";", "}", "if", "(", "TARGET_ALTIVEC", "&&", "rclass", "==", "ALTIVEC_REGS", "&&", "(", "ALTIVEC_VECTOR_MODE", "(", "from", ")", "+", "ALTIVEC_VECTOR_MODE", "(", "to", ")", ")", "==", "1", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "." ]

[ "rs6000", "8", "8", "8", "8", "8", "8", "15", "16", "8", "16", "1" ]

[]

[ "<s>", "virtual", "const", "MCObjectFormat", "&", "getObjectFormat", "(", ")", "const", "{", "return", "Format", ";", "}", "</s>" ]

[ "Get", "the", "object", "format", "for", "this", "triple", "." ]

[ "X86" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"RISCV Branch Selector\"", ";", "}", "</s>" ]

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

[ "RISCV", "\"RISCV Branch Selector\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "classifyLEAReg", "(", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "Src", ",", "unsigned", "Opc", ",", "bool", "AllowSP", ",", "Register", "&", "NewSrc", ",", "bool", "&", "isKill", ",", "MachineOperand", "&", "ImplicitOp", ",", "LiveVariables", "*", "LV", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "AllowSP", ")", "{", "RC", "=", "Opc", "!=", "X86", "::", "LEA32r", "?", "&", "X86", "::", "GR64RegClass", ":", "&", "X86", "::", "GR32RegClass", ";", "}", "else", "{", "RC", "=", "Opc", "!=", "X86", "::", "LEA32r", "?", "&", "X86", "::", "GR64_NOSPRegClass", ":", "&", "X86", "::", "GR32_NOSPRegClass", ";", "}", "Register", "SrcReg", "=", "Src", ".", "getReg", "(", ")", ";", "isKill", "=", "MI", ".", "killsRegister", "(", "SrcReg", ")", ";", "if", "(", "Opc", "!=", "X86", "::", "LEA64_32r", ")", "{", "NewSrc", "=", "SrcReg", ";", "assert", "(", "!", "Src", ".", "isUndef", "(", ")", "&&", "\"Undef op doesn't need optimization\"", ")", ";", "if", "(", "NewSrc", ".", "isVirtual", "(", ")", "&&", "!", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "NewSrc", ",", "RC", ")", ")", "return", "false", ";", "return", "true", ";", "}", "if", "(", "SrcReg", ".", "isPhysical", "(", ")", ")", "{", "ImplicitOp", "=", "Src", ";", "ImplicitOp", ".", "setImplicit", "(", ")", ";", "NewSrc", "=", "getX86SubSuperRegister", "(", "SrcReg", ",", "64", ")", ";", "assert", "(", "!", "Src", ".", "isUndef", "(", ")", "&&", "\"Undef op doesn't need optimization\"", ")", ";", "}", "else", "{", "NewSrc", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MachineInstr", "*", "Copy", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ")", ".", "addReg", "(", "NewSrc", ",", "RegState", "::", "Define", "|", "RegState", "::", "Undef", ",", "X86", "::", "sub_32bit", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "isKill", "=", "true", ";", "if", "(", "LV", ")", "LV", "->", "replaceKillInstruction", "(", "SrcReg", ",", "MI", ",", "*", "Copy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Given", "an", "operand", "within", "a", "MachineInstr", ",", "insert", "preceding", "code", "to", "put", "it", "into", "the", "right", "format", "for", "a", "particular", "kind", "of", "LEA", "instruction", "." ]

[ "X86", "X86", "X86::LEA32r", "X86::GR64RegClass", "X86::GR32RegClass", "X86::LEA32r", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "X86::LEA64_32r", "\"Undef op doesn't need optimization\"", "X86", "64", "\"Undef op doesn't need optimization\"", "X86::sub_32bit" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "char", "*", "SpillLibCall", "=", "getSpillLibCallName", "(", "*", "MF", ",", "CSI", ")", ";", "if", "(", "SpillLibCall", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "RISCV", "::", "PseudoCALLReg", ")", ",", "RISCV", "::", "X5", ")", ".", "addExternalSymbol", "(", "SpillLibCall", ",", "RISCVII", "::", "MO_CALL", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "MBB", ".", "addLiveIn", "(", "CS", ".", "getReg", "(", ")", ")", ";", "}", "const", "auto", "&", "NonLibcallCSI", "=", "getNonLibcallCSI", "(", "*", "MF", ",", "CSI", ")", ";", "for", "(", "auto", "&", "CS", ":", "NonLibcallCSI", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CS", ".", "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", "(", ")", "." ]

[ "RISCV", "RISCV", "RISCV::PseudoCALLReg", "RISCV::X5", "RISCVII::MO_CALL" ]

[]

[ "<s>", "static", "tree", "spu_gimplify_va_arg_expr", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", "ATTRIBUTE_UNUSED", ")", "{", "tree", "f_args", ",", "f_skip", ";", "tree", "args", ",", "skip", ";", "HOST_WIDE_INT", "size", ",", "rsize", ";", "tree", "addr", ",", "tmp", ";", "bool", "pass_by_reference_p", ";", "f_args", "=", "TYPE_FIELDS", "(", "TREE_TYPE", "(", "va_list_type_node", ")", ")", ";", "f_skip", "=", "DECL_CHAIN", "(", "f_args", ")", ";", "args", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_args", ")", ",", "valist", ",", "f_args", ",", "NULL_TREE", ")", ";", "skip", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_skip", ")", ",", "valist", ",", "f_skip", ",", "NULL_TREE", ")", ";", "addr", "=", "create_tmp_var", "(", "ptr_type_node", ",", "\"va_arg\"", ")", ";", "pass_by_reference_p", "=", "pass_by_reference", "(", "NULL", ",", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "false", ")", ";", "if", "(", "pass_by_reference_p", ")", "type", "=", "build_pointer_type", "(", "type", ")", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "rsize", "=", "(", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", "*", "UNITS_PER_WORD", ";", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "unshare_expr", "(", "args", ")", ",", "rsize", ")", ";", "tmp", "=", "build2", "(", "TRUTH_AND_EXPR", ",", "boolean_type_node", ",", "build2", "(", "GT_EXPR", ",", "boolean_type_node", ",", "tmp", ",", "unshare_expr", "(", "skip", ")", ")", ",", "build2", "(", "LE_EXPR", ",", "boolean_type_node", ",", "unshare_expr", "(", "args", ")", ",", "unshare_expr", "(", "skip", ")", ")", ")", ";", "tmp", "=", "build3", "(", "COND_EXPR", ",", "ptr_type_node", ",", "tmp", ",", "fold_build_pointer_plus_hwi", "(", "unshare_expr", "(", "skip", ")", ",", "32", ")", ",", "unshare_expr", "(", "args", ")", ")", ";", "gimplify_assign", "(", "addr", ",", "tmp", ",", "pre_p", ")", ";", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "addr", ",", "rsize", ")", ";", "gimplify_assign", "(", "unshare_expr", "(", "args", ")", ",", "tmp", ",", "pre_p", ")", ";", "addr", "=", "fold_convert", "(", "build_pointer_type_for_mode", "(", "type", ",", "ptr_mode", ",", "true", ")", ",", "addr", ")", ";", "if", "(", "pass_by_reference_p", ")", "addr", "=", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "</s>" ]

[ "Gimplify", "va_arg", "by", "updating", "the", "va_list", "structure", "VALIST", "as", "required", "to", "retrieve", "an", "argument", "of", "type", "TYPE", ",", "and", "returning", "that", "argument", ".", "ret", "=", "va_arg", "(", "VALIST", ",", "TYPE", ")", ";", "generates", "code", "equivalent", "to", ":", "paddedsize", "=", "(", "sizeof", "(", "TYPE", ")", "+", "15", ")", "&", "-16", ";", "if", "(", "VALIST.__args", "+", "paddedsize", ">", "VALIST.__skip", "&", "&", "VALIST.__args", "<", "=", "VALIST.__skip", ")", "addr", "=", "VALIST.__skip", "+", "32", ";", "else", "addr", "=", "VALIST.__args", ";", "VALIST.__args", "=", "addr", "+", "paddedsize", ";", "ret", "=", "*", "(", "TYPE", "*", ")", "addr", ";" ]

[ "spu", "\"va_arg\"", "1", "32" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_xchg_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_add_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_sub_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_nand_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_max_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_min_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_umax_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_umin_i32", ":", "case", "Intrinsic", "::", "riscv_masked_cmpxchg_i32", ":", "PointerType", "*", "PtrTy", "=", "cast", "<", "PointerType", ">", "(", "I", ".", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "PtrTy", "->", "getElementType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "Align", "(", "4", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "RISCV", "RISCV", "Intrinsic::riscv_masked_atomicrmw_xchg_i32", "Intrinsic::riscv_masked_atomicrmw_add_i32", "Intrinsic::riscv_masked_atomicrmw_sub_i32", "Intrinsic::riscv_masked_atomicrmw_nand_i32", "Intrinsic::riscv_masked_atomicrmw_max_i32", "Intrinsic::riscv_masked_atomicrmw_min_i32", "Intrinsic::riscv_masked_atomicrmw_umax_i32", "Intrinsic::riscv_masked_atomicrmw_umin_i32", "Intrinsic::riscv_masked_cmpxchg_i32", "0", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0", "4" ]

[]

[ "<s>", "unsigned", "int", "h8300_insn_length_from_table", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "switch", "(", "get_attr_length_table", "(", "insn", ")", ")", "{", "case", "LENGTH_TABLE_NONE", ":", "gcc_unreachable", "(", ")", ";", "case", "LENGTH_TABLE_ADDB", ":", "return", "h8300_binary_length", "(", "insn", ",", "&", "addb_length_table", ")", ";", "case", "LENGTH_TABLE_ADDW", ":", "return", "h8300_binary_length", "(", "insn", ",", "&", "addw_length_table", ")", ";", "case", "LENGTH_TABLE_ADDL", ":", "return", "h8300_binary_length", "(", "insn", ",", "&", "addl_length_table", ")", ";", "case", "LENGTH_TABLE_LOGICB", ":", "return", "h8300_binary_length", "(", "insn", ",", "&", "logicb_length_table", ")", ";", "case", "LENGTH_TABLE_MOVB", ":", "return", "h8300_move_length", "(", "operands", ",", "&", "movb_length_table", ")", ";", "case", "LENGTH_TABLE_MOVW", ":", "return", "h8300_move_length", "(", "operands", ",", "&", "movw_length_table", ")", ";", "case", "LENGTH_TABLE_MOVL", ":", "return", "h8300_move_length", "(", "operands", ",", "&", "movl_length_table", ")", ";", "case", "LENGTH_TABLE_MOVA", ":", "return", "h8300_mova_length", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "case", "LENGTH_TABLE_MOVA_ZERO", ":", "return", "h8300_mova_length", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "const0_rtx", ")", ";", "case", "LENGTH_TABLE_UNARY", ":", "return", "h8300_unary_length", "(", "operands", "[", "0", "]", ")", ";", "case", "LENGTH_TABLE_MOV_IMM4", ":", "return", "2", "+", "h8300_classify_operand", "(", "operands", "[", "0", "]", ",", "0", ",", "0", ")", ";", "case", "LENGTH_TABLE_SHORT_IMMEDIATE", ":", "return", "h8300_short_immediate_length", "(", "operands", "[", "0", "]", ")", ";", "case", "LENGTH_TABLE_BITFIELD", ":", "return", "h8300_bitfield_length", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "case", "LENGTH_TABLE_BITBRANCH", ":", "return", "h8300_bitfield_length", "(", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", "-", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Compute", "the", "length", "of", "INSN", "based", "on", "its", "length_table", "attribute", ".", "OPERANDS", "is", "the", "array", "of", "its", "operands", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_init_fp16_types", "(", "void", ")", "{", "aarch64_fp16_type_node", "=", "make_node", "(", "REAL_TYPE", ")", ";", "TYPE_PRECISION", "(", "aarch64_fp16_type_node", ")", "=", "16", ";", "layout_type", "(", "aarch64_fp16_type_node", ")", ";", "(", "*", "lang_hooks", ".", "types", ".", "register_builtin_type", ")", "(", "aarch64_fp16_type_node", ",", "\"__fp16\"", ")", ";", "aarch64_fp16_ptr_type_node", "=", "build_pointer_type", "(", "aarch64_fp16_type_node", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "backend", "types", "that", "support", "the", "user-visible", "__fp16", "type", ",", "also", "initialize", "a", "pointer", "to", "that", "type", ",", "to", "be", "used", "when", "forming", "HFAs", "." ]

[ "aarch64", "16", "\"__fp16\"" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_VectorCall", "||", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", "||", "STI", "->", "getRegisterInfo", "(", ")", "->", "hasSVEArgsOrReturn", "(", "MF", ")", ")", "{", "auto", "*", "TS", "=", "static_cast", "<", "AArch64TargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "TS", "->", "emitDirectiveVariantPCS", "(", "CurrentFnSym", ")", ";", "}", "return", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "loadImmediate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "Reg", ",", "uint64_t", "Value", ")", "const", "{", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "isInt", "<", "16", ">", "(", "Value", ")", ")", "Opcode", "=", "SystemZ", "::", "LGHI", ";", "else", "if", "(", "SystemZ", "::", "isImmLL", "(", "Value", ")", ")", "Opcode", "=", "SystemZ", "::", "LLILL", ";", "else", "if", "(", "SystemZ", "::", "isImmLH", "(", "Value", ")", ")", "{", "Opcode", "=", "SystemZ", "::", "LLILH", ";", "Value", ">>=", "16", ";", "}", "else", "{", "assert", "(", "isInt", "<", "32", ">", "(", "Value", ")", "&&", "\"Huge values not handled yet\"", ")", ";", "Opcode", "=", "SystemZ", "::", "LGFI", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addImm", "(", "Value", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "SystemZ", "SystemZ", "16", "SystemZ::LGHI", "SystemZ::isImmLL", "SystemZ::LLILL", "SystemZ::isImmLH", "SystemZ::LLILH", "16", "32", "\"Huge values not handled yet\"", "SystemZ::LGFI" ]

[]

[ "<s>", "bool", "TeakTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "const", "LoadSDNode", "*", "ld", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ";", "const", "StoreSDNode", "*", "st", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ";", "if", "(", "!", "(", "ld", "&&", "ld", "->", "getMemoryVT", "(", ")", "==", "MVT", "::", "i16", ")", "&&", "!", "(", "st", "&&", "st", "->", "getMemoryVT", "(", ")", "==", "MVT", "::", "i16", ")", ")", "return", "false", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", "&&", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SUB", ")", "return", "false", ";", "if", "(", "const", "ConstantSDNode", "*", "rhs", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ")", "{", "int", "rhsc", "=", "rhs", "->", "getSExtValue", "(", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", ")", "rhsc", "=", "-", "rhsc", ";", "if", "(", "rhsc", "!=", "1", "&&", "rhsc", "!=", "-", "1", ")", "return", "false", ";", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "rhsc", ",", "DL", ",", "MVT", "::", "i16", ")", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "Teak", "Teak", "ISD::MemIndexedMode", "MVT::i16", "MVT::i16", "ISD::ADD", "ISD::SUB", "1", "ISD::SUB", "1", "1", "0", "MVT::i16", "ISD::POST_INC" ]

[]

[ "<s>", "static", "rtx", "xtensa_static_chain", "(", "const_tree", "ARG_UNUSED", "(", "fndecl_or_type", ")", ",", "bool", "incoming_p", ")", "{", "if", "(", "TARGET_WINDOWED_ABI", ")", "{", "rtx", "base", "=", "incoming_p", "?", "arg_pointer_rtx", ":", "stack_pointer_rtx", ";", "return", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "base", ",", "-", "5", "*", "UNITS_PER_WORD", ")", ")", ";", "}", "else", "return", "gen_rtx_REG", "(", "Pmode", ",", "A8_REG", ")", ";", "}", "</s>" ]

[ "The", "static", "chain", "is", "passed", "in", "memory", ".", "Provide", "rtx", "giving", "'mem", "'", "expressions", "that", "denote", "where", "they", "are", "stored", "." ]

[ "xtensa", "5" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon-specific loop carried reuse for HVX vectors\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon-specific loop carried reuse for HVX vectors\"" ]

[]

[ "<s>", "void", "SystemZTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "bool", "HasCall", "=", "false", ";", "unsigned", "NumStores", "=", "0", ";", "for", "(", "auto", "&", "BB", ":", "L", "->", "blocks", "(", ")", ")", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "&", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "&", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "isLoweredToCall", "(", "F", ")", ")", "HasCall", "=", "true", ";", "if", "(", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memcpy", "||", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memset", ")", "NumStores", "++", ";", "}", "else", "{", "HasCall", "=", "true", ";", "}", "}", "if", "(", "isa", "<", "StoreInst", ">", "(", "&", "I", ")", ")", "{", "Type", "*", "MemAccessTy", "=", "I", ".", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ";", "NumStores", "+=", "getMemoryOpCost", "(", "Instruction", "::", "Store", ",", "MemAccessTy", ",", "0", ",", "0", ")", ";", "}", "}", "unsigned", "const", "Max", "=", "(", "NumStores", "?", "(", "12", "/", "NumStores", ")", ":", "UINT_MAX", ")", ";", "if", "(", "HasCall", ")", "{", "UP", ".", "FullUnrollMaxCount", "=", "Max", ";", "UP", ".", "MaxCount", "=", "1", ";", "return", ";", "}", "UP", ".", "MaxCount", "=", "Max", ";", "if", "(", "UP", ".", "MaxCount", "<=", "1", ")", "return", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "75", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "Intrinsic::memcpy", "Intrinsic::memset", "0", "0", "0", "12", "1", "1", "75", "4" ]

[]

[ "<s>", "static", "bool", "mmix_rtx_costs", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "TARGET_RTX_COSTS", "." ]

[ "mmix" ]

[]

[ "<s>", "enum", "reg_class", "aarch64_regno_regclass", "(", "unsigned", "regno", ")", "{", "if", "(", "GP_REGNUM_P", "(", "regno", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "regno", "==", "SP_REGNUM", ")", "return", "STACK_REG", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "POINTER_REGS", ";", "if", "(", "FP_REGNUM_P", "(", "regno", ")", ")", "return", "FP_LO_REGNUM_P", "(", "regno", ")", "?", "FP_LO_REGS", ":", "FP_REGS", ";", "if", "(", "PR_REGNUM_P", "(", "regno", ")", ")", "return", "PR_LO_REGNUM_P", "(", "regno", ")", "?", "PR_LO_REGS", ":", "PR_HI_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "REGNO_REG_CLASS", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CallConv", "==", "CallingConv", "::", "WebKit_JS", "?", "RetCC_AArch64_WebKit_JS", ":", "RetCC_AArch64_AAPCS", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "AArch64", "AArch64", "ISD::OutputArg", "AArch64", "AArch64", "16" ]

[]

[ "<s>", "rtx", "rs6000_gen_le_vsx_permute", "(", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rs6000_const_vec", "(", "mode", ")", ")", ";", "return", "gen_rtx_VEC_SELECT", "(", "mode", ",", "source", ",", "par", ")", ";", "}", "</s>" ]

[ "Generate", "a", "permute", "rtx", "that", "represents", "an", "lxvd2x", ",", "stxvd2x", ",", "or", "xxpermdi", "for", "a", "VSX", "load", "or", "store", "operation", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "aarch64_expand_sve_mem_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "machine_mode", "pred_mode", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "ptrue", "=", "aarch64_ptrue_reg", "(", "pred_mode", ")", ";", "if", "(", "!", "register_operand", "(", "src", ",", "mode", ")", "&&", "!", "register_operand", "(", "dest", ",", "mode", ")", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "MEM_P", "(", "src", ")", ")", "aarch64_emit_sve_pred_move", "(", "tmp", ",", "ptrue", ",", "src", ")", ";", "else", "emit_move_insn", "(", "tmp", ",", "src", ")", ";", "src", "=", "tmp", ";", "}", "aarch64_emit_sve_pred_move", "(", "dest", ",", "ptrue", ",", "src", ")", ";", "}", "</s>" ]

[ "Expand", "a", "pre-RA", "SVE", "data", "move", "from", "SRC", "to", "DEST", "in", "which", "at", "least", "one", "operand", "is", "in", "memory", ".", "In", "this", "case", "we", "need", "to", "use", "the", "predicated", "LD1", "and", "ST1", "instead", "of", "LDR", "and", "STR", ",", "both", "for", "correctness", "on", "big-endian", "targets", "and", "because", "LD1", "and", "ST1", "support", "a", "wider", "range", "of", "addressing", "modes", ".", "PRED_MODE", "is", "the", "mode", "of", "the", "predicate", ".", "See", "the", "comment", "at", "the", "head", "of", "aarch64-sve.md", "for", "details", "about", "the", "big-endian", "handling", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_RegMask", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_RegMask", ";", "return", "CSR_64_RT_AllRegs_RegMask", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_TLS_Darwin_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_RegMask", ";", "case", "CallingConv", "::", "X86_RegCall", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "return", "(", "HasSSE", "?", "CSR_Win64_RegCall_RegMask", ":", "CSR_Win64_RegCall_NoSSE_RegMask", ")", ";", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_SysV64_RegCall_RegMask", ":", "CSR_SysV64_RegCall_NoSSE_RegMask", ")", ";", "}", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_32_RegCall_RegMask", ":", "CSR_32_RegCall_NoSSE_RegMask", ")", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_RegMask", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "return", "CSR_64_RegMask", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_64_AllRegs_RegMask", ";", "return", "CSR_64_AllRegs_NoSSE_RegMask", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_RegMask", ";", "return", "CSR_32_AllRegs_RegMask", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "if", "(", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_64_SwiftError_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "return", "CSR_32_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

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

[]

[ "<s>", "SDNode", "*", "SparcDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "static", "rtx", "ix86_delegitimize_address", "(", "rtx", "x", ")", "{", "return", "ix86_delegitimize_address_1", "(", "x", ",", "false", ")", ";", "}", "</s>" ]

[ "In", "the", "name", "of", "slightly", "smaller", "debug", "output", ",", "and", "to", "cater", "to", "general", "assembler", "lossage", ",", "recognize", "PIC+GOTOFF", "and", "turn", "it", "back", "into", "a", "direct", "symbol", "reference", ".", "On", "Darwin", ",", "this", "is", "necessary", "to", "avoid", "a", "crash", ",", "because", "Darwin", "has", "a", "different", "PIC", "label", "for", "each", "routine", "but", "the", "DWARF", "debugging", "information", "is", "not", "associated", "with", "any", "particular", "routine", ",", "so", "it", "'s", "necessary", "to", "remove", "references", "to", "the", "PIC", "label", "from", "RTL", "stored", "by", "the", "DWARF", "output", "code", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "prologue_saved_reg_p", "(", "int", "regno", ")", "{", "gcc_assert", "(", "GP_REG_P", "(", "regno", ")", ")", ";", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "frame_pointer_needed", "&&", "regno", ">=", "HARD_FRAME_POINTER_REGNUM", "&&", "regno", "<", "HARD_FRAME_POINTER_REGNUM", "+", "GET_MODE_SIZE", "(", "Pmode", ")", ")", "return", "true", ";", "if", "(", "regno", "==", "RA_REGNUM", "&&", "df_regs_ever_live_p", "(", "RA_REGNUM", ")", ")", "return", "true", ";", "if", "(", "regno", "==", "RA_REGNUM", "+", "1", "&&", "df_regs_ever_live_p", "(", "RA_REGNUM", "+", "1", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "REGNO", "should", "be", "saved", "in", "the", "prologue", "." ]

[ "pru", "1", "1" ]

[]

[ "<s>", "void", "LanaiDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", ";", "}", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "Constant", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "{", "ConstantSDNode", "*", "ConstNode", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", ";", "if", "(", "ConstNode", "->", "isZero", "(", ")", ")", "{", "SDValue", "New", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "Lanai", "::", "R0", ",", "MVT", "::", "i32", ")", ";", "return", "ReplaceNode", "(", "Node", ",", "New", ".", "getNode", "(", ")", ")", ";", "}", "if", "(", "ConstNode", "->", "isAllOnes", "(", ")", ")", "{", "SDValue", "New", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "Lanai", "::", "R1", ",", "MVT", "::", "i32", ")", ";", "return", "ReplaceNode", "(", "Node", ",", "New", ".", "getNode", "(", ")", ")", ";", "}", "}", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "selectFrameIndex", "(", "Node", ")", ";", "return", ";", "default", ":", "break", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "\"== \"", "\"\\n\"", "0", "ISD::Constant", "MVT::i32", "Lanai::R0", "MVT::i32", "Lanai::R1", "MVT::i32", "ISD::FrameIndex" ]

[]

[ "<s>", "SDValue", "mprocTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "}", "</s>" ]

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

[ "mproc", "mproc" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "new", "CoalesceFeaturesAndStripAtomics", "(", "&", "getWebAssemblyTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyAddMissingPrototypes", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerGlobalDtors", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixFunctionBitcasts", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";", "basicCheckForEHAndSjLj", "(", "TM", ")", ";", "if", "(", "!", "WasmEnableEmEH", "&&", "!", "WasmEnableEH", ")", "{", "addPass", "(", "createLowerInvokePass", "(", ")", ")", ";", "addPass", "(", "createUnreachableBlockEliminationPass", "(", ")", ")", ";", "}", "if", "(", "WasmEnableEmEH", "||", "WasmEnableEmSjLj", "||", "WasmEnableSjLj", ")", "addPass", "(", "createWebAssemblyLowerEmscriptenEHSjLj", "(", ")", ")", ";", "addPass", "(", "createIndirectBrExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "const", "predefined_function_abi", "&", "aarch64_insn_callee_abi", "(", "const", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", ";", "rtx", "unspec", "=", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", "&&", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_CALLEE_ABI", ")", ";", "return", "function_abis", "[", "INTVAL", "(", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ")", "]", ";", "}", "</s>" ]

[ "Implement", "TARGET_INSN_CALLEE_ABI", "." ]

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

[]

[ "<s>", "static", "int", "avr_operand_rtx_cost", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", ",", "enum", "rtx_code", "outer", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "int", "total", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "return", "0", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "COSTS_N_INSNS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "default", ":", "break", ";", "}", "total", "=", "0", ";", "avr_rtx_costs", "(", "x", ",", "code", ",", "outer", ",", "&", "total", ")", ";", "return", "total", ";", "}", "</s>" ]

[ "Mutually", "recursive", "subroutine", "of", "avr_rtx_cost", "for", "calculating", "the", "cost", "of", "an", "RTX", "operand", "given", "its", "context", ".", "X", "is", "the", "rtx", "of", "the", "operand", ",", "MODE", "is", "its", "mode", ",", "and", "OUTER", "is", "the", "rtx_code", "of", "this", "operand", "'s", "parent", "operator", "." ]

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

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "isAsmClobberable", "(", "const", "MachineFunction", "&", "MF", ",", "MCRegister", "PhysReg", ")", "const", "{", "return", "!", "MF", ".", "getRegInfo", "(", ")", ".", "isReserved", "(", "PhysReg", ")", ";", "}", "</s>" ]

[ "Returns", "false", "if", "we", "ca", "n't", "guarantee", "that", "Physreg", ",", "specified", "as", "an", "IR", "asm", "clobber", "constraint", ",", "will", "be", "preserved", "across", "the", "statement", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "const", "CallLowering", "*", "AArch64Subtarget", "::", "getCallLowering", "(", ")", "const", "{", "if", "(", "!", "CallLoweringInfo", ")", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "TLInfo", ")", ")", ";", "return", "CallLoweringInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "PatmosSPClone", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Single-Path] Clone functions reachable from single-path roots\\n\"", ")", ";", "SmallSet", "<", "std", "::", "string", ",", "128", ">", "used", ";", "loadFromGlobalVariable", "(", "used", ",", "M", ".", "getGlobalVariable", "(", "\"llvm.used\"", ")", ")", ";", "SmallSet", "<", "std", "::", "string", ",", "16", ">", "blacklst", ";", "blacklst", ".", "insert", "(", "Blacklist", ",", "Blacklist", "+", "(", "sizeof", "Blacklist", "/", "sizeof", "Blacklist", "[", "0", "]", ")", ")", ";", "for", "(", "Module", "::", "iterator", "I", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "Function", "*", "F", "=", "I", "++", ";", "if", "(", "F", "->", "isDeclaration", "(", ")", ")", "continue", ";", "if", "(", "F", "->", "hasFnAttribute", "(", "\"sp-root\"", ")", ")", "{", "handleRoot", "(", "F", ")", ";", "(", "void", ")", "SPRoots", ".", "erase", "(", "F", "->", "getName", "(", ")", ")", ";", "continue", ";", "}", "if", "(", "SPRoots", ".", "count", "(", "F", "->", "getName", "(", ")", ")", ")", "{", "F", "->", "addFnAttr", "(", "\"sp-root\"", ")", ";", "handleRoot", "(", "F", ")", ";", "(", "void", ")", "SPRoots", ".", "erase", "(", "F", "->", "getName", "(", ")", ")", ";", "continue", ";", "}", "if", "(", "used", ".", "count", "(", "F", "->", "getName", "(", ")", ")", "&&", "!", "blacklst", ".", "count", "(", "F", "->", "getName", "(", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Used: \"", "<<", "F", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "explore", "(", "cloneAndMark", "(", "F", ",", "true", ")", ",", "true", ")", ";", "continue", ";", "}", "}", "return", "(", "NumSPRoots", "+", "NumSPReachable", "+", "NumSPUsed", ")", ">", "0", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "Patmos", "Patmos", "\"[Single-Path] Clone functions reachable from single-path roots\\n\"", "128", "\"llvm.used\"", "16", "0", "\"sp-root\"", "\"sp-root\"", "\"Used: \"", "\"\\n\"", "0" ]

[]

[ "<s>", "static", "void", "rs6000_set_default_type_attributes", "(", "tree", "type", ")", "{", "if", "(", "rs6000_default_long_calls", "&&", "(", "TREE_CODE", "(", "type", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "METHOD_TYPE", ")", ")", "TYPE_ATTRIBUTES", "(", "type", ")", "=", "tree_cons", "(", "get_identifier", "(", "\"longcall\"", ")", ",", "NULL_TREE", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "darwin_set_default_type_attributes", "(", "type", ")", ";", "}", "</s>" ]

[ "Set", "longcall", "attributes", "on", "all", "functions", "declared", "when", "rs6000_default_long_calls", "is", "true", "." ]

[ "powerpcspe", "\"longcall\"" ]

[]

[ "<s>", "bool", "mergeStoresAfterLegalization", "(", "EVT", "VT", ")", "const", "override", "{", "return", "!", "useSVEForFixedLengthVectors", "(", ")", ";", "}", "</s>" ]

[ "Do", "not", "merge", "vector", "stores", "after", "legalization", "because", "that", "may", "conflict", "with", "x86-specific", "store", "splitting", "optimizations", "." ]

[ "AArch64" ]

[]

[ "<s>", "int", "h8300_hard_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_H8300", ")", "return", "(", "(", "regno", "&", "1", ")", "==", "0", ")", "||", "(", "mode", "==", "HImode", ")", "||", "(", "mode", "==", "QImode", ")", ";", "else", "return", "regno", "==", "MAC_REG", "?", "mode", "==", "SImode", ":", "1", ";", "}", "</s>" ]

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

[ "h8300", "1", "0", "1" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegRegOnly", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "SelectAddressRegReg", "(", "N", ",", "Base", ",", "Index", ",", "DAG", ")", ")", "return", "true", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "Base", "=", "DAG", ".", "getRegister", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "ZERO8", ":", "PPC", "::", "ZERO", ",", "N", ".", "getValueType", "(", ")", ")", ";", "Index", "=", "N", ";", "return", "true", ";", "}", "</s>" ]

[ "SelectAddressRegRegOnly", "-", "Given", "the", "specified", "addressed", ",", "force", "it", "to", "be", "represented", "as", "an", "indexed", "[", "r+r", "]", "operation", "." ]

[ "PowerPC", "PPC", "ISD::ADD", "0", "1", "PPC", "PPC::ZERO8", "PPC::ZERO" ]

[]

[ "<s>", "static", "X86Operand", "*", "CreateMem", "(", "unsigned", "SegReg", ",", "const", "MCExpr", "*", "Disp", ",", "unsigned", "BaseReg", ",", "unsigned", "IndexReg", ",", "unsigned", "Scale", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "unsigned", "Size", "=", "0", ",", "bool", "NeedSizeDir", "=", "false", ")", "{", "assert", "(", "(", "SegReg", "||", "BaseReg", "||", "IndexReg", ")", "&&", "\"Invalid memory operand!\"", ")", ";", "assert", "(", "(", "(", "Scale", "==", "1", "||", "Scale", "==", "2", "||", "Scale", "==", "4", "||", "Scale", "==", "8", ")", ")", "&&", "\"Invalid scale!\"", ")", ";", "X86Operand", "*", "Res", "=", "new", "X86Operand", "(", "Memory", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Mem", ".", "SegReg", "=", "SegReg", ";", "Res", "->", "Mem", ".", "Disp", "=", "Disp", ";", "Res", "->", "Mem", ".", "BaseReg", "=", "BaseReg", ";", "Res", "->", "Mem", ".", "IndexReg", "=", "IndexReg", ";", "Res", "->", "Mem", ".", "Scale", "=", "Scale", ";", "Res", "->", "Mem", ".", "Size", "=", "Size", ";", "Res", "->", "Mem", ".", "NeedSizeDir", "=", "NeedSizeDir", ";", "Res", "->", "AddressOf", "=", "false", ";", "return", "Res", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"Invalid memory operand!\"", "1", "2", "4", "8", "\"Invalid scale!\"", "X86", "X86" ]

[]

[ "<s>", "int", "ia64_depz_field_mask", "(", "rtx", "rop", ",", "rtx", "rshift", ")", "{", "unsigned", "HOST_WIDE_INT", "op", "=", "INTVAL", "(", "rop", ")", ";", "unsigned", "HOST_WIDE_INT", "shift", "=", "INTVAL", "(", "rshift", ")", ";", "op", ">>=", "shift", ";", "return", "exact_log2", "(", "op", "+", "1", ")", ";", "}", "</s>" ]

[ "Check", "if", "OP", "is", "a", "mask", "suitible", "for", "use", "with", "SHIFT", "in", "a", "dep.z", "instruction", ".", "Return", "the", "length", "of", "the", "field", ",", "or", "<", "=", "0", "on", "failure", "." ]

[ "ia64", "1" ]

[]

[ "<s>", "tree", "resolve", "(", "function_resolver", "&", "r", ")", "const", "override", "{", "unsigned", "int", "i", ",", "nargs", ";", "type_suffix_index", "type", ";", "if", "(", "!", "r", ".", "check_gp_argument", "(", "1", ",", "i", ",", "nargs", ")", "||", "(", "type", "=", "r", ".", "infer_vector_type", "(", "i", ")", ")", "==", "NUM_TYPE_SUFFIXES", ")", "return", "error_mark_node", ";", "if", "(", "type", "==", "TYPE_SUFFIX_b", ")", "return", "r", ".", "resolve_to", "(", "r", ".", "mode_suffix_id", ",", "type", ")", ";", "if", "(", "type_suffixes", "[", "type", "]", ".", "integer_p", "&&", "type_suffixes", "[", "type", "]", ".", "element_bits", "<", "64", ")", "{", "type_suffix_index", "wide_suffix", "=", "find_type_suffix", "(", "type_suffixes", "[", "type", "]", ".", "tclass", ",", "type_suffixes", "[", "type", "]", ".", "element_bits", "*", "2", ")", ";", "if", "(", "tree", "res", "=", "r", ".", "lookup_form", "(", "r", ".", "mode_suffix_id", ",", "wide_suffix", ")", ")", "return", "res", ";", "}", "return", "r", ".", "report_no_such_form", "(", "type", ")", ";", "}", "</s>" ]

[ "If", "the", "call", "is", "erroneous", ",", "report", "an", "appropriate", "error", "and", "return", "error_mark_node", ".", "Otherwise", ",", "if", "the", "function", "is", "overloaded", ",", "return", "the", "decl", "of", "the", "non-overloaded", "function", ".", "Return", "NULL_TREE", "otherwise", ",", "indicating", "that", "the", "call", "should", "be", "processed", "in", "the", "normal", "way", "." ]

[ "aarch64", "1", "64", "2" ]

[]

[ "<s>", "Value", "*", "HexagonTargetLowering", "::", "emitStoreConditional", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "BasicBlock", "*", "BB", "=", "Builder", ".", "GetInsertBlock", "(", ")", ";", "Module", "*", "M", "=", "BB", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "Ty", "=", "Val", "->", "getType", "(", ")", ";", "unsigned", "SZ", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "assert", "(", "(", "SZ", "==", "32", "||", "SZ", "==", "64", ")", "&&", "\"Only 32/64-bit atomic stores supported\"", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "(", "SZ", "==", "32", ")", "?", "Intrinsic", "::", "hexagon_S2_storew_locked", ":", "Intrinsic", "::", "hexagon_S4_stored_locked", ";", "Value", "*", "Fn", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "IntID", ")", ";", "Value", "*", "Call", "=", "Builder", ".", "CreateCall", "(", "Fn", ",", "{", "Addr", ",", "Val", "}", ",", "\"stcx\"", ")", ";", "Value", "*", "Cmp", "=", "Builder", ".", "CreateICmpEQ", "(", "Call", ",", "Builder", ".", "getInt32", "(", "0", ")", ",", "\"\"", ")", ";", "Value", "*", "Ext", "=", "Builder", ".", "CreateZExt", "(", "Cmp", ",", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Ext", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "Hexagon", "Hexagon", "32", "64", "\"Only 32/64-bit atomic stores supported\"", "Intrinsic::ID", "32", "Intrinsic::hexagon_S2_storew_locked", "Intrinsic::hexagon_S4_stored_locked", "Intrinsic::getDeclaration", "\"stcx\"", "0", "\"\"" ]

[]

[ "<s>", "bool", "ThumbDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ")", "const", "{", "uint32_t", "insn", "=", "0", ";", "uint16_t", "insn1", "=", "0", ";", "uint8_t", "bytes", "[", "2", "]", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "2", ",", "(", "uint8_t", "*", ")", "bytes", ",", "NULL", ")", "==", "-", "1", ")", "return", "false", ";", "insn", "=", "(", "bytes", "[", "1", "]", "<<", "8", ")", "|", "bytes", "[", "0", "]", ";", "unsigned", "bits15_11", "=", "slice", "(", "insn", ",", "15", ",", "11", ")", ";", "bool", "IsThumb2", "=", "false", ";", "if", "(", "bits15_11", "==", "0x1D", "||", "bits15_11", "==", "0x1E", "||", "bits15_11", "==", "0x1F", ")", "{", "IsThumb2", "=", "true", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", "+", "2", ",", "2", ",", "(", "uint8_t", "*", ")", "bytes", ",", "NULL", ")", "==", "-", "1", ")", "return", "false", ";", "insn1", "=", "(", "bytes", "[", "1", "]", "<<", "8", ")", "|", "bytes", "[", "0", "]", ";", "insn", "=", "(", "insn", "<<", "16", "|", "insn1", ")", ";", "}", "unsigned", "Opcode", "=", "decodeThumbSideEffect", "(", "IsThumb2", ",", "insn", ")", ";", "if", "(", "Thumb2PreloadOpcodeNoPCI", "(", "Opcode", ")", "&&", "slice", "(", "insn", ",", "19", ",", "16", ")", "==", "15", ")", "Opcode", "=", "T2Morph2Preload2PCI", "(", "Opcode", ")", ";", "ARMFormat", "Format", "=", "ARMFormats", "[", "Opcode", "]", ";", "Size", "=", "IsThumb2", "?", "4", ":", "2", ";", "DEBUG", "(", "{", "errs", "(", ")", "<<", "\"Opcode=\"", "<<", "Opcode", "<<", "\" Name=\"", "<<", "ARMUtils", "::", "OpcodeName", "(", "Opcode", ")", "<<", "\" Format=\"", "<<", "stringForARMFormat", "(", "Format", ")", "<<", "'('", "<<", "(", "int", ")", "Format", "<<", "\")\\n\"", ";", "showBitVector", "(", "errs", "(", ")", ",", "insn", ")", ";", "}", ")", ";", "ARMBasicMCBuilder", "*", "Builder", "=", "CreateMCBuilder", "(", "Opcode", ",", "Format", ")", ";", "Builder", "->", "SetSession", "(", "const_cast", "<", "Session", "*", ">", "(", "&", "SO", ")", ")", ";", "if", "(", "!", "Builder", ")", "return", "false", ";", "if", "(", "!", "Builder", "->", "Build", "(", "MI", ",", "insn", ")", ")", "return", "false", ";", "delete", "Builder", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "0", "0", "2", "2", "1", "1", "8", "0", "15", "11", "0x1D", "0x1E", "0x1F", "2", "2", "1", "1", "8", "0", "16", "19", "16", "15", "ARM", "ARM", "4", "2", "\"Opcode=\"", "\" Name=\"", "ARMUtils::OpcodeName", "\" Format=\"", "ARM", "\")\\n\"", "ARM" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "Expr", "==", "0", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "AAP", "0", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_vector_alignment_reachable", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "is_packed", ")", "{", "if", "(", "is_packed", ")", "return", "false", ";", "if", "(", "TARGET_32BIT", ")", "{", "if", "(", "rs6000_alignment_flags", "==", "MASK_ALIGN_NATURAL", ")", "return", "true", ";", "if", "(", "rs6000_alignment_flags", "==", "MASK_ALIGN_POWER", ")", "return", "true", ";", "return", "false", ";", "}", "else", "{", "if", "(", "TARGET_MACHO", ")", "return", "false", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Return", "true", "iff", ",", "data", "reference", "of", "TYPE", "can", "reach", "vector", "alignment", "(", "16", ")", "after", "applying", "N", "number", "of", "iterations", ".", "This", "routine", "does", "not", "determine", "how", "may", "iterations", "are", "required", "to", "reach", "desired", "alignment", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "xstormy16_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "address", ")", "{", "HOST_WIDE_INT", "offset", ";", "int", "pre_dec", ",", "post_inc", ";", "if", "(", "CONST_INT_P", "(", "address", ")", ")", "{", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "address", ")", "&", "0xFFFF", ")", ";", "return", ";", "}", "if", "(", "CONSTANT_P", "(", "address", ")", "||", "LABEL_P", "(", "address", ")", ")", "{", "output_addr_const", "(", "file", ",", "address", ")", ";", "return", ";", "}", "if", "(", "GET_CODE", "(", "address", ")", "==", "PLUS", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "XEXP", "(", "address", ",", "1", ")", ")", ")", ";", "offset", "=", "INTVAL", "(", "XEXP", "(", "address", ",", "1", ")", ")", ";", "address", "=", "XEXP", "(", "address", ",", "0", ")", ";", "}", "else", "offset", "=", "0", ";", "pre_dec", "=", "(", "GET_CODE", "(", "address", ")", "==", "PRE_DEC", ")", ";", "post_inc", "=", "(", "GET_CODE", "(", "address", ")", "==", "POST_INC", ")", ";", "if", "(", "pre_dec", "||", "post_inc", ")", "address", "=", "XEXP", "(", "address", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "address", ")", ")", ";", "fputc", "(", "'('", ",", "file", ")", ";", "if", "(", "pre_dec", ")", "fputs", "(", "\"--\"", ",", "file", ")", ";", "fputs", "(", "reg_names", "[", "REGNO", "(", "address", ")", "]", ",", "file", ")", ";", "if", "(", "post_inc", ")", "fputs", "(", "\"++\"", ",", "file", ")", ";", "if", "(", "offset", "!=", "0", ")", "fprintf", "(", "file", ",", "\",\"", "HOST_WIDE_INT_PRINT_DEC", ",", "offset", ")", ";", "fputc", "(", "')'", ",", "file", ")", ";", "}", "</s>" ]

[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "." ]

[ "stormy16", "0xFFFF", "1", "1", "0", "0", "0", "\"--\"", "\"++\"", "0", "\",\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "expandIndirectJTBranch", "(", "const", "SDLoc", "&", "dl", ",", "SDValue", "Value", ",", "SDValue", "Addr", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "Module", "*", "M", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", ";", "Metadata", "*", "IsCFProtectionSupported", "=", "M", "->", "getModuleFlag", "(", "\"cf-protection-branch\"", ")", ";", "if", "(", "IsCFProtectionSupported", ")", "{", "return", "DAG", ".", "getNode", "(", "X86ISD", "::", "NT_BRIND", ",", "dl", ",", "MVT", "::", "Other", ",", "Value", ",", "Addr", ")", ";", "}", "return", "TargetLowering", "::", "expandIndirectJTBranch", "(", "dl", ",", "Value", ",", "Addr", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Expands", "target", "specific", "indirect", "branch", "for", "the", "case", "of", "JumpTable", "expansion", "." ]

[ "X86", "X86", "\"cf-protection-branch\"", "X86ISD::NT_BRIND", "MVT::Other" ]

[]

[ "<s>", "static", "bool", "is_cracked_insn", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "return", "false", ";", "if", "(", "rs6000_sched_groups", "&&", "(", "rs6000_cpu", "==", "PROCESSOR_POWER4", "||", "rs6000_cpu", "==", "PROCESSOR_POWER5", ")", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "(", "type", "==", "TYPE_LOAD", "&&", "get_attr_sign_extend", "(", "insn", ")", "==", "SIGN_EXTEND_YES", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_NO", ")", "||", "(", "type", "==", "TYPE_LOAD", "&&", "get_attr_sign_extend", "(", "insn", ")", "==", "SIGN_EXTEND_NO", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", "&&", "get_attr_indexed", "(", "insn", ")", "==", "INDEXED_NO", ")", "||", "(", "type", "==", "TYPE_STORE", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", "&&", "get_attr_indexed", "(", "insn", ")", "==", "INDEXED_NO", ")", "||", "(", "(", "type", "==", "TYPE_FPLOAD", "||", "type", "==", "TYPE_FPSTORE", ")", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", ")", "||", "type", "==", "TYPE_DELAYED_CR", "||", "(", "type", "==", "TYPE_EXTS", "&&", "get_attr_dot", "(", "insn", ")", "==", "DOT_YES", ")", "||", "(", "type", "==", "TYPE_SHIFT", "&&", "get_attr_dot", "(", "insn", ")", "==", "DOT_YES", "&&", "get_attr_var_shift", "(", "insn", ")", "==", "VAR_SHIFT_NO", ")", "||", "(", "type", "==", "TYPE_MUL", "&&", "get_attr_dot", "(", "insn", ")", "==", "DOT_YES", ")", "||", "type", "==", "TYPE_DIV", "||", "(", "type", "==", "TYPE_INSERT", "&&", "get_attr_size", "(", "insn", ")", "==", "SIZE_32", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "function", "returns", "true", "if", "INSN", "is", "cracked", "into", "2", "instructions", "by", "the", "processor", "(", "and", "therefore", "occupies", "2", "issue", "slots", ")", "." ]

[ "rs6000" ]

[]

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

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

[ "RI5CY" ]

[]

[ "<s>", "bool", "HexagonEarlyIfConversion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "HII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MFN", "=", "&", "MF", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MBPI", "=", "EnableHexagonBP", "?", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ":", "nullptr", ";", "Deleted", ".", "clear", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineLoopInfo", "::", "iterator", "I", "=", "MLI", "->", "begin", "(", ")", ",", "E", "=", "MLI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Changed", "|=", "visitLoop", "(", "*", "I", ")", ";", "Changed", "|=", "visitLoop", "(", "nullptr", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "arc_asm_insn_p", "(", "rtx", "x", ")", "{", "int", "i", ",", "j", ";", "if", "(", "x", "==", "0", ")", "return", "0", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "ASM_OPERANDS", ":", "case", "ASM_INPUT", ":", "return", "1", ";", "case", "SET", ":", "return", "arc_asm_insn_p", "(", "SET_SRC", "(", "x", ")", ")", ";", "case", "PARALLEL", ":", "j", "=", "0", ";", "for", "(", "i", "=", "XVECLEN", "(", "x", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "j", "+=", "arc_asm_insn_p", "(", "XVECEXP", "(", "x", ",", "0", ",", "i", ")", ")", ";", "if", "(", "j", ">", "0", ")", "return", "1", ";", "break", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Given", "a", "rtx", ",", "check", "if", "it", "is", "an", "assembly", "instruction", "or", "not", "." ]

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

[]

[ "<s>", "void", "TOYInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "TOY", "::", "LOADrr", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "TOY", "::", "ZERO", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY::LOADrr", "TOY::ZERO" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "Inst", ".", "getNumOperands", "(", ")", "==", "0", ")", "return", "false", ";", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "0", "]", ".", "OperandType", "==", "MCOI", "::", "OPERAND_PCREL", ")", "{", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Size", "+", "Imm", ";", "return", "true", ";", "}", "else", "{", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "false", ";", "Target", "=", "Imm", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "Lanai", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "rtx", "rs6000_pre_atomic_barrier", "(", "rtx", "mem", ",", "enum", "memmodel", "model", ")", "{", "rtx", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "!", "legitimate_indirect_address_p", "(", "addr", ",", "reload_completed", ")", "&&", "!", "legitimate_indexed_address_p", "(", "addr", ",", "reload_completed", ")", ")", "{", "addr", "=", "force_reg", "(", "Pmode", ",", "addr", ")", ";", "mem", "=", "replace_equiv_address_nv", "(", "mem", ",", "addr", ")", ";", "}", "switch", "(", "model", ")", "{", "case", "MEMMODEL_RELAXED", ":", "case", "MEMMODEL_CONSUME", ":", "case", "MEMMODEL_ACQUIRE", ":", "break", ";", "case", "MEMMODEL_RELEASE", ":", "case", "MEMMODEL_ACQ_REL", ":", "emit_insn", "(", "gen_lwsync", "(", ")", ")", ";", "break", ";", "case", "MEMMODEL_SEQ_CST", ":", "emit_insn", "(", "gen_hwsync", "(", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "mem", ";", "}", "</s>" ]

[ "Expand", "barriers", "before", "and", "after", "a", "load_locked/store_cond", "sequence", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "Z80oldTargetLowering", "::", "isZExtFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "return", "VT1", "==", "MVT", "::", "i16", "&&", "VT2", "==", "MVT", "::", "i24", "&&", "Subtarget", ".", "is24Bit", "(", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "MVT::i16", "MVT::i24" ]

[]

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

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

[ "M68k", "M68k" ]

[]

[ "<s>", "bool", "BPFIRPeephole", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "return", "BPFIRPeepholeImpl", "(", "F", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Dummy", ";", "if", "(", "isFrameStoreOpcode", "(", "MI", ".", "getOpcode", "(", ")", ",", "Dummy", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isStoreToStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "hasStoreToStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addInstSelector", "(", ")", "{", "AMDGPUPassConfig", "::", "addInstSelector", "(", ")", ";", "addPass", "(", "&", "SIFixSGPRCopiesID", ")", ";", "addPass", "(", "createSILowerI1CopiesPass", "(", ")", ")", ";", "addPass", "(", "createSIFixupVectorISelPass", "(", ")", ")", ";", "addPass", "(", "createSIAddIMGInitPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "r10k_insert_cache_barriers", "(", "void", ")", "{", "int", "*", "rev_post_order", ";", "unsigned", "int", "i", ",", "n", ";", "basic_block", "bb", ";", "sbitmap", "protected_bbs", ";", "rtx_insn", "*", "insn", ",", "*", "end", ";", "rtx", "unprotected_region", ";", "if", "(", "TARGET_MIPS16", ")", "{", "sorry", "(", "\"%qs does not support MIPS16 code\"", ",", "\"-mr10k-cache-barrier\"", ")", ";", "return", ";", "}", "calculate_dominance_info", "(", "CDI_DOMINATORS", ")", ";", "protected_bbs", "=", "sbitmap_alloc", "(", "last_basic_block_for_fn", "(", "cfun", ")", ")", ";", "bitmap_clear", "(", "protected_bbs", ")", ";", "rev_post_order", "=", "XNEWVEC", "(", "int", ",", "last_basic_block_for_fn", "(", "cfun", ")", ")", ";", "n", "=", "pre_and_rev_post_order_compute", "(", "NULL", ",", "rev_post_order", ",", "false", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "bb", "=", "BASIC_BLOCK_FOR_FN", "(", "cfun", ",", "rev_post_order", "[", "i", "]", ")", ";", "if", "(", "r10k_protected_bb_p", "(", "bb", ",", "protected_bbs", ")", ")", "unprotected_region", "=", "NULL_RTX", ";", "else", "unprotected_region", "=", "pc_rtx", ";", "end", "=", "NEXT_INSN", "(", "BB_END", "(", "bb", ")", ")", ";", "for", "(", "insn", "=", "BB_HEAD", "(", "bb", ")", ";", "insn", "!=", "end", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "unprotected_region", "&&", "USEFUL_INSN_P", "(", "insn", ")", ")", "{", "if", "(", "recog_memoized", "(", "insn", ")", "==", "CODE_FOR_mips_cache", ")", "unprotected_region", "=", "NULL_RTX", ";", "else", "{", "if", "(", "unprotected_region", "==", "pc_rtx", ")", "unprotected_region", "=", "insn", ";", "if", "(", "r10k_needs_protection_p", "(", "insn", ")", ")", "{", "emit_insn_before", "(", "gen_r10k_cache_barrier", "(", ")", ",", "unprotected_region", ")", ";", "unprotected_region", "=", "NULL_RTX", ";", "}", "}", "}", "if", "(", "CALL_P", "(", "insn", ")", ")", "unprotected_region", "=", "pc_rtx", ";", "}", "if", "(", "unprotected_region", "==", "NULL_RTX", ")", "bitmap_set_bit", "(", "protected_bbs", ",", "bb", "->", "index", ")", ";", "}", "XDELETEVEC", "(", "rev_post_order", ")", ";", "sbitmap_free", "(", "protected_bbs", ")", ";", "free_dominance_info", "(", "CDI_DOMINATORS", ")", ";", "}", "</s>" ]

[ "Implement", "-mr10k-cache-barrier=", "for", "the", "current", "function", "." ]

[ "mips", "\"%qs does not support MIPS16 code\"", "\"-mr10k-cache-barrier\"", "0" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "combineZERO_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "combineSIGN_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "combineSIGN_EXTEND_INREG", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "MERGE_HIGH", ":", "case", "SystemZISD", "::", "MERGE_LOW", ":", "return", "combineMERGE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "combineLOAD", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "combineSTORE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "combineVECTOR_SHUFFLE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "combineEXTRACT_VECTOR_ELT", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "JOIN_DWORDS", ":", "return", "combineJOIN_DWORDS", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "STRICT_FP_ROUND", ":", "case", "ISD", "::", "FP_ROUND", ":", "return", "combineFP_ROUND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "STRICT_FP_EXTEND", ":", "case", "ISD", "::", "FP_EXTEND", ":", "return", "combineFP_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "combineINT_TO_FP", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BSWAP", ":", "return", "combineBSWAP", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "BR_CCMASK", ":", "return", "combineBR_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "SELECT_CCMASK", ":", "return", "combineSELECT_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "GET_CCMASK", ":", "return", "combineGET_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "return", "combineIntDIVREM", "(", "N", ",", "DCI", ")", ";", "}", "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", "." ]

[ "SystemZ", "SystemZ", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::SIGN_EXTEND_INREG", "SystemZISD::MERGE_HIGH", "SystemZISD::MERGE_LOW", "ISD::LOAD", "ISD::STORE", "ISD::VECTOR_SHUFFLE", "ISD::EXTRACT_VECTOR_ELT", "SystemZISD::JOIN_DWORDS", "ISD::STRICT_FP_ROUND", "ISD::FP_ROUND", "ISD::STRICT_FP_EXTEND", "ISD::FP_EXTEND", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::BSWAP", "SystemZISD::BR_CCMASK", "SystemZISD::SELECT_CCMASK", "SystemZISD::GET_CCMASK", "ISD::SDIV", "ISD::UDIV", "ISD::SREM", "ISD::UREM" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemmove", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "return", "EmitSpecializedLibcall", "(", "DAG", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "Size", ",", "Align", ",", "RTLIB", "::", "MEMMOVE", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memmove", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "for", "(", "std", "::", "map", "<", "const", "char", "*", ",", "const", "llvm", "::", "Mips16HardFloatInfo", "::", "FuncSignature", "*", ">", "::", "const_iterator", "it", "=", "MipsFI", "->", "StubsNeeded", ".", "begin", "(", ")", ";", "it", "!=", "MipsFI", "->", "StubsNeeded", ".", "end", "(", ")", ";", "++", "it", ")", "{", "const", "char", "*", "Symbol", "=", "it", "->", "first", ";", "const", "llvm", "::", "Mips16HardFloatInfo", "::", "FuncSignature", "*", "Signature", "=", "it", "->", "second", ";", "if", "(", "StubsNeeded", ".", "find", "(", "Symbol", ")", "==", "StubsNeeded", ".", "end", "(", ")", ")", "StubsNeeded", "[", "Symbol", "]", "=", "Signature", ";", "}", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "NaClAlignIndirectJumpTargets", "(", "MF", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips16HardFloatInfo::FuncSignature", "Mips", "Mips", "Mips16HardFloatInfo::FuncSignature" ]

[]

[ "<s>", "void", "Tile64FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "Tile64RegisterInfo", "*", "TRI", "=", "static_cast", "<", "const", "Tile64RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "Tile64MachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "Tile64MachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "hasCalls", "=", "MFI", "->", "hasCalls", "(", ")", ";", "unsigned", "Offset", "=", "FuncInfo", "->", "getArgAreaOffset", "(", ")", "+", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "I", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "MBB", ".", "begin", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "II", "!=", "IE", ";", "++", "II", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "II", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "T64", "::", "NEWSLOT_ADDR", ")", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "(", "MI", ")", ";", "unsigned", "Dest", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "hasCalls", ")", "{", "TRI", "->", "addOffset", "(", "MBB", ",", "MBBI", ",", "DL", ",", "Dest", ",", "Src", ",", "Offset", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "T64", "::", "MOVE", ")", ",", "Dest", ")", ".", "addReg", "(", "Src", ")", ";", "}", "++", "II", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "--", "II", ";", "}", "}", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "Tile64", "T64::NEWSLOT_ADDR", "0", "1", "T64::MOVE" ]

[]

[ "<s>", "static", "tree", "arm_get_cookie_size", "(", "tree", "type", ")", "{", "tree", "size", ";", "if", "(", "!", "TARGET_AAPCS_BASED", ")", "return", "default_cxx_get_cookie_size", "(", "type", ")", ";", "size", "=", "build_int_cst", "(", "sizetype", ",", "8", ")", ";", "return", "size", ";", "}", "</s>" ]

[ "The", "EABI", "specifies", "that", "all", "array", "cookies", "are", "8", "bytes", "long", "." ]

[ "arm", "8" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeFrameSize", "=", "0", ";", "unsigned", "LowReg", "=", "0", ",", "HighReg", "=", "0", ",", "StartOffset", "=", "-", "1U", ",", "EndOffset", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RegClass", "=", "CSI", "[", "i", "]", ".", "getRegClass", "(", ")", ";", "if", "(", "RegClass", "!=", "&", "SystemZ", "::", "FP64RegClass", ")", "{", "unsigned", "Offset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "CalleeFrameSize", "+=", "8", ";", "if", "(", "StartOffset", ">", "Offset", ")", "{", "LowReg", "=", "Reg", ";", "StartOffset", "=", "Offset", ";", "}", "if", "(", "EndOffset", "<", "Offset", ")", "{", "HighReg", "=", "Reg", ";", "EndOffset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "}", "}", "}", "MFI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "MFI", "->", "setLowReg", "(", "LowReg", ")", ";", "MFI", "->", "setHighReg", "(", "HighReg", ")", ";", "if", "(", "StartOffset", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "(", "LowReg", "==", "HighReg", "?", "SystemZ", "::", "MOV64mr", ":", "SystemZ", "::", "MOV64mrm", ")", ")", ")", ";", "MIB", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ".", "addImm", "(", "StartOffset", ")", ";", "if", "(", "LowReg", "==", "HighReg", ")", "MIB", ".", "addReg", "(", "0", ")", ";", "MIB", ".", "addReg", "(", "LowReg", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "LowReg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "HighReg", ",", "RegState", "::", "Kill", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Reg", "!=", "LowReg", "&&", "Reg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "}", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RegClass", "=", "CSI", "[", "i", "]", ".", "getRegClass", "(", ")", ";", "if", "(", "RegClass", "==", "&", "SystemZ", "::", "FP64RegClass", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RegClass", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "0", "0", "1U", "0", "0", "SystemZ::FP64RegClass", "8", "SystemZ::MOV64mr", "SystemZ::MOV64mrm", "SystemZ::R15D", "0", "0", "0", "SystemZ::FP64RegClass" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "schedNode", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"** Scheduling SU(\"", "<<", "SU", "->", "NodeNum", "<<", "\") \"", ";", "if", "(", "Available", ".", "size", "(", ")", "==", "1", ")", "dbgs", "(", ")", "<<", "\"(only one) \"", ";", "Candidate", "c", "(", "SU", ",", "*", "HazardRec", ")", ";", "c", ".", "dumpCosts", "(", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "Available", ".", "erase", "(", "SU", ")", ";", "HazardRec", "->", "EmitInstruction", "(", "SU", ")", ";", "}", "</s>" ]

[ "ScheduleDAGMI", "has", "scheduled", "an", "instruction", "-", "tell", "HazardRec", "about", "it", "." ]

[ "SystemZ", "SystemZ", "\"** Scheduling SU(\"", "\") \"", "1", "\"(only one) \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "HexagonTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "Kind", ".", "isBSS", "(", ")", "||", "Kind", ".", "isDataNoRel", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", "{", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "TM", ".", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "Hexagon", "Hexagon" ]

[]

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

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

[ "SNES" ]

[]

[ "<s>", "Optional", "<", "uint64_t", ">", "ARMMCInstrAnalysis", "::", "evaluateMemoryOperandAddress", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "*", "STI", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "!", "Desc", ".", "mayLoad", "(", ")", ")", "return", "None", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "unsigned", "IndexMode", "=", "(", "TSFlags", "&", "ARMII", "::", "IndexModeMask", ")", ">>", "ARMII", "::", "IndexModeShift", ";", "if", "(", "IndexMode", "!=", "ARMII", "::", "IndexModeNone", ")", "return", "None", ";", "unsigned", "OpIndex", "=", "Desc", ".", "NumDefs", ";", "while", "(", "OpIndex", "<", "Desc", ".", "getNumOperands", "(", ")", "&&", "Desc", ".", "OpInfo", "[", "OpIndex", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_MEMORY", ")", "++", "OpIndex", ";", "if", "(", "OpIndex", "==", "Desc", ".", "getNumOperands", "(", ")", ")", "return", "None", ";", "Addr", "&=", "~", "0x3", ";", "switch", "(", "Desc", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "{", "default", ":", "Addr", "+=", "8", ";", "break", ";", "case", "ARMII", "::", "ThumbFrm", ":", "Addr", "+=", "4", ";", "break", ";", "case", "ARMII", "::", "VFPLdStFrm", ":", "Addr", "+=", "STI", "->", "getFeatureBits", "(", ")", "[", "ARM", "::", "ModeThumb", "]", "?", "4", ":", "8", ";", "break", ";", "}", "unsigned", "AddrMode", "=", "(", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", ";", "switch", "(", "AddrMode", ")", "{", "default", ":", "return", "None", ";", "case", "ARMII", "::", "AddrMode_i12", ":", "return", "evaluateMemOpAddrForAddrMode_i12", "(", "Inst", ",", "Desc", ",", "OpIndex", ",", "Addr", ")", ";", "case", "ARMII", "::", "AddrMode3", ":", "return", "evaluateMemOpAddrForAddrMode3", "(", "Inst", ",", "Desc", ",", "OpIndex", ",", "Addr", ")", ";", "case", "ARMII", "::", "AddrMode5", ":", "return", "evaluateMemOpAddrForAddrMode5", "(", "Inst", ",", "Desc", ",", "OpIndex", ",", "Addr", ")", ";", "case", "ARMII", "::", "AddrMode5FP16", ":", "return", "evaluateMemOpAddrForAddrMode5FP16", "(", "Inst", ",", "Desc", ",", "OpIndex", ",", "Addr", ")", ";", "case", "ARMII", "::", "AddrModeT2_i8s4", ":", "return", "evaluateMemOpAddrForAddrModeT2_i8s4", "(", "Inst", ",", "Desc", ",", "OpIndex", ",", "Addr", ")", ";", "case", "ARMII", "::", "AddrModeT2_pc", ":", "return", "evaluateMemOpAddrForAddrModeT2_pc", "(", "Inst", ",", "Desc", ",", "OpIndex", ",", "Addr", ")", ";", "case", "ARMII", "::", "AddrModeT1_s", ":", "return", "evaluateMemOpAddrForAddrModeT1_s", "(", "Inst", ",", "Desc", ",", "OpIndex", ",", "Addr", ")", ";", "}", "}", "</s>" ]

[ "Given", "an", "instruction", "tries", "to", "get", "the", "address", "of", "a", "memory", "operand", "." ]

[ "ARM", "ARM", "ARMII::IndexModeMask", "ARMII::IndexModeShift", "ARMII::IndexModeNone", "0x3", "ARMII::FormMask", "8", "ARMII::ThumbFrm", "4", "ARMII::VFPLdStFrm", "ARM::ModeThumb", "4", "8", "ARMII::AddrModeMask", "ARMII::AddrMode_i12", "ARMII::AddrMode3", "ARMII::AddrMode5", "ARMII::AddrMode5FP16", "ARMII::AddrModeT2_i8s4", "ARMII::AddrModeT2_pc", "ARMII::AddrModeT1_s" ]

[]

[ "<s>", "static", "void", "cr16_conditional_register_usage", "(", "void", ")", "{", "if", "(", "flag_pic", ")", "{", "fixed_regs", "[", "12", "]", "=", "call_used_regs", "[", "12", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Implements", "the", "macro", "TARGET_CONDITIONAL_REGISTER_USAGE", "." ]

[ "cr16", "12", "12", "1" ]

[]

[ "<s>", "static", "bool", "returning_call_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "(", "!", "SIBLING_CALL_P", "(", "insn", ")", "&&", "get_attr_type", "(", "insn", ")", "!=", "TYPE_CALLP", "&&", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SHADOW", ")", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "false", ";", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_CALL", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determine", "whether", "INSN", "is", "a", "call", "that", "needs", "to", "have", "a", "return", "label", "placed", "." ]

[ "c6x", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isVectorLoadExtDesirable", "(", "SDValue", "ExtVal", ")", "const", "{", "if", "(", "ExtVal", ".", "getValueType", "(", ")", ".", "isScalableVector", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "vector", "load", "into", "ExtVal", "(", "a", "sign", ",", "zero", ",", "or", "any", "extend", "node", ")", "is", "profitable", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "default_promote_function_mode_always_promote", "arc_use_by_pieces_infrastructure_p", "static", "int", "arc_sched_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "DFmode", "&&", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "REG", ")", "{", "return", "priority", "+", "20", ";", "}", "return", "priority", ";", "}", "</s>" ]

[ "Implement", "TARGET_USE_BY_PIECES_INFRASTRUCTURE_P", "." ]

[ "arc", "20" ]

[]

[ "<s>", "static", "int", "rs6000_variable_issue_1", "(", "rtx_insn", "*", "insn", ",", "int", "more", ")", "{", "last_scheduled_insn", "=", "insn", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "{", "cached_can_issue_more", "=", "more", ";", "return", "cached_can_issue_more", ";", "}", "if", "(", "insn_terminates_group_p", "(", "insn", ",", "current_group", ")", ")", "{", "cached_can_issue_more", "=", "0", ";", "return", "cached_can_issue_more", ";", "}", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "more", ";", "if", "(", "rs6000_sched_groups", ")", "{", "if", "(", "is_microcoded_insn", "(", "insn", ")", ")", "cached_can_issue_more", "=", "0", ";", "else", "if", "(", "is_cracked_insn", "(", "insn", ")", ")", "cached_can_issue_more", "=", "more", ">", "2", "?", "more", "-", "2", ":", "0", ";", "else", "cached_can_issue_more", "=", "more", "-", "1", ";", "return", "cached_can_issue_more", ";", "}", "if", "(", "rs6000_tune", "==", "PROCESSOR_CELL", "&&", "is_nonpipeline_insn", "(", "insn", ")", ")", "return", "0", ";", "cached_can_issue_more", "=", "more", "-", "1", ";", "return", "cached_can_issue_more", ";", "}", "</s>" ]

[ "Power4", "load", "update", "and", "store", "update", "instructions", "are", "cracked", "into", "a", "load", "or", "store", "and", "an", "integer", "insn", "which", "are", "executed", "in", "the", "same", "cycle", ".", "Branches", "have", "their", "own", "dispatch", "slot", "which", "does", "not", "count", "against", "the", "GCC", "issue", "rate", ",", "but", "it", "changes", "the", "program", "flow", "so", "there", "are", "no", "other", "instructions", "to", "issue", "in", "this", "cycle", "." ]

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

[]

[ "<s>", "bool", "mips_can_use_return_insn", "(", "void", ")", "{", "if", "(", "cfun", "->", "machine", "->", "interrupt_handler_p", ")", "return", "false", ";", "if", "(", "!", "reload_completed", ")", "return", "false", ";", "if", "(", "crtl", "->", "profile", ")", "return", "false", ";", "if", "(", "mips16_cfun_returns_in_fpr_p", "(", ")", ")", "return", "false", ";", "return", "(", "cfun", "->", "machine", "->", "frame", ".", "total_size", "==", "0", "&&", "!", "cfun", "->", "machine", "->", "use_frame_header_for_callee_saved_regs", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "mips", "0" ]

[]

[ "<s>", "void", "nds32_asm_file_end_for_isr", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NDS32_N_ISR_VECTORS", ";", "i", "++", ")", "if", "(", "nds32_isr_vectors", "[", "i", "]", ".", "category", "!=", "NDS32_ISR_NONE", ")", "break", ";", "if", "(", "i", "==", "NDS32_N_ISR_VECTORS", ")", "return", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ------------------------------------\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! The isr vector information:\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ------------------------------------\\n\"", ")", ";", "if", "(", "nds32_isr_vectors", "[", "0", "]", ".", "category", "==", "NDS32_ISR_RESET", ")", "{", "nds32_emit_isr_reset_content", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ------------------------------------\\n\"", ")", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<", "NDS32_N_ISR_VECTORS", ";", "i", "++", ")", "{", "if", "(", "nds32_isr_vectors", "[", "i", "]", ".", "category", "==", "NDS32_ISR_INTERRUPT", "||", "nds32_isr_vectors", "[", "i", "]", ".", "category", "==", "NDS32_ISR_EXCEPTION", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t! interrupt/exception vector %02d\\n\"", ",", "i", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! security level: %d\\n\"", ",", "nds32_isr_vectors", "[", "i", "]", ".", "security_level", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ------------------------------------\\n\"", ")", ";", "nds32_emit_isr_jmptbl_section", "(", "i", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ....................................\\n\"", ")", ";", "nds32_emit_isr_vector_section", "(", "i", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ------------------------------------\\n\"", ")", ";", "}", "}", "}", "</s>" ]

[ "A", "helper", "function", "to", "handle", "isr", "stuff", "at", "the", "end", "of", "asm", "file", "." ]

[ "nds32", "0", "\"\\t! ------------------------------------\\n\"", "\"\\t! The isr vector information:\\n\"", "\"\\t! ------------------------------------\\n\"", "0", "\"\\t! ------------------------------------\\n\"", "1", "\"\\t! interrupt/exception vector %02d\\n\"", "\"\\t! security level: %d\\n\"", "\"\\t! ------------------------------------\\n\"", "\"\\t! ....................................\\n\"", "\"\\t! ------------------------------------\\n\"" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "ECLair", "\"Invalid type access!\"" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "int", "AltOpc", "=", "PPC", "::", "getAltVSXFMAOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "AltOpc", "==", "-", "1", ")", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "return", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "2", ",", "3", ")", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "PowerPC", "PPC", "PPC::getAltVSXFMAOpcode", "1", "2", "3" ]

[]

[ "<s>", "MCSection", "*", "RISCVELFTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "Align", "&", "Alignment", ")", "const", "{", "if", "(", "isConstantInSmallSection", "(", "DL", ",", "C", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "getSectionForConstant", "(", "DL", ",", "Kind", ",", "C", ",", "Alignment", ")", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isExtended", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ";", "if", "(", "(", "F", ">>", "HexagonII", "::", "ExtendedPos", ")", "&", "HexagonII", "::", "ExtendedMask", ")", "return", "true", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "HexagonII", "::", "HMOTF_ConstExtended", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "outliner", "::", "InstrType", "RISCVInstrInfo", "::", "getOutliningType", "(", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "Flags", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MI", ".", "isPosition", "(", ")", ")", "{", "if", "(", "MI", ".", "isCFIInstruction", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Invisible", ";", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "isInlineAsm", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "&&", "!", "MBB", "->", "succ_empty", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "RISCV", "::", "X5", ",", "TRI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "RISCV", "::", "X5", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "for", "(", "const", "auto", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MO", ".", "isMBB", "(", ")", "||", "MO", ".", "isBlockAddress", "(", ")", "||", "MO", ".", "isCPI", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Invisible", ";", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "}", "</s>" ]

[ "Returns", "how", "or", "if", "MIT", "should", "be", "outlined", "." ]

[ "RISCV", "RISCV", "RISCV::X5", "RISCV::X5" ]

[]

[ "<s>", "inline", "Predicate", "getPredicate", "(", "unsigned", "Condition", ",", "unsigned", "Hint", ")", "{", "return", "(", "Predicate", ")", "(", "(", "Condition", "&", "~", "BR_HINT_MASK", ")", "|", "(", "Hint", "&", "BR_HINT_MASK", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "comparison", "predicate", "underlying", "the", "intrinsic", "." ]

[ "PowerPC" ]

[]

[ "<s>", "rtx", "sh_function_arg", "(", "CUMULATIVE_ARGS", "*", "ca", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ")", "{", "if", "(", "!", "TARGET_SH5", "&&", "mode", "==", "VOIDmode", ")", "return", "GEN_INT", "(", "ca", "->", "renesas_abi", "?", "1", ":", "0", ")", ";", "if", "(", "!", "TARGET_SH5", "&&", "PASS_IN_REG_P", "(", "*", "ca", ",", "mode", ",", "type", ")", "&&", "(", "named", "||", "!", "(", "TARGET_HITACHI", "||", "ca", "->", "renesas_abi", ")", ")", ")", "{", "int", "regno", ";", "if", "(", "mode", "==", "SCmode", "&&", "TARGET_SH4", "&&", "TARGET_LITTLE_ENDIAN", "&&", "(", "!", "FUNCTION_ARG_SCmode_WART", "||", "(", "ROUND_REG", "(", "*", "ca", ",", "mode", ")", "&", "1", ")", ")", ")", "{", "rtx", "r1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SFmode", ",", "BASE_ARG_REG", "(", "mode", ")", "+", "(", "ROUND_REG", "(", "*", "ca", ",", "mode", ")", "^", "1", ")", ")", ",", "const0_rtx", ")", ";", "rtx", "r2", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SFmode", ",", "BASE_ARG_REG", "(", "mode", ")", "+", "(", "(", "ROUND_REG", "(", "*", "ca", ",", "mode", ")", "+", "1", ")", "^", "1", ")", ")", ",", "GEN_INT", "(", "4", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "SCmode", ",", "gen_rtvec", "(", "2", ",", "r1", ",", "r2", ")", ")", ";", "}", "if", "(", "(", "TARGET_HITACHI", "||", "ca", "->", "renesas_abi", ")", "&&", "ca", "->", "free_single_fp_reg", "&&", "mode", "==", "SFmode", ")", "return", "gen_rtx_REG", "(", "mode", ",", "ca", "->", "free_single_fp_reg", ")", ";", "regno", "=", "(", "BASE_ARG_REG", "(", "mode", ")", "+", "ROUND_REG", "(", "*", "ca", ",", "mode", ")", ")", "^", "(", "mode", "==", "SFmode", "&&", "TARGET_SH4", "&&", "TARGET_LITTLE_ENDIAN", "!=", "0", "&&", "!", "TARGET_HITACHI", "&&", "!", "ca", "->", "renesas_abi", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "if", "(", "TARGET_SH5", ")", "{", "if", "(", "mode", "==", "VOIDmode", "&&", "TARGET_SHCOMPACT", ")", "return", "GEN_INT", "(", "ca", "->", "call_cookie", ")", ";", "if", "(", "mode", "==", "SFmode", "&&", "ca", "->", "free_single_fp_reg", ")", "return", "SH5_PROTOTYPED_FLOAT_ARG", "(", "*", "ca", ",", "mode", ",", "ca", "->", "free_single_fp_reg", ")", ";", "if", "(", "(", "GET_SH_ARG_CLASS", "(", "mode", ")", "==", "SH_ARG_FLOAT", ")", "&&", "(", "named", "||", "!", "ca", "->", "prototype_p", ")", "&&", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "<", "NPARM_REGS", "(", "SFmode", ")", ")", "{", "if", "(", "!", "ca", "->", "prototype_p", "&&", "TARGET_SHMEDIA", ")", "return", "SH5_PROTOTYPELESS_FLOAT_ARG", "(", "*", "ca", ",", "mode", ")", ";", "return", "SH5_PROTOTYPED_FLOAT_ARG", "(", "*", "ca", ",", "mode", ",", "FIRST_FP_PARM_REG", "+", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", ")", ";", "}", "if", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "<", "NPARM_REGS", "(", "SImode", ")", "&&", "(", "!", "TARGET_SHCOMPACT", "||", "(", "!", "SHCOMPACT_FORCE_ON_STACK", "(", "mode", ",", "type", ")", "&&", "!", "SH5_WOULD_BE_PARTIAL_NREGS", "(", "*", "ca", ",", "mode", ",", "type", ",", "named", ")", ")", ")", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "(", "FIRST_PARM_REG", "+", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", ")", ")", ";", "}", "return", "0", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "sh", "1", "0", "1", "1", "1", "1", "4", "2", "0", "0", "0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SystemZRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_SystemZ_SwiftError_SaveList", ";", "return", "CSR_SystemZ_SaveList", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "SetupMachineFunction", "(", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "SwitchToSection", "(", "TAI", "->", "SectionForGlobal", "(", "F", ")", ")", ";", "switch", "(", "F", "->", "getLinkage", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Unknown linkage type!\"", ")", ";", "case", "Function", "::", "PrivateLinkage", ":", "case", "Function", "::", "InternalLinkage", ":", "break", ";", "case", "Function", "::", "ExternalLinkage", ":", "O", "<<", "\"\\t.globl\\t\"", "<<", "CurrentFnName", "<<", "'\\n'", ";", "break", ";", "case", "Function", "::", "WeakAnyLinkage", ":", "case", "Function", "::", "WeakODRLinkage", ":", "case", "Function", "::", "LinkOnceAnyLinkage", ":", "case", "Function", "::", "LinkOnceODRLinkage", ":", "O", "<<", "\"\\t.globl\\t\"", "<<", "CurrentFnName", "<<", "'\\n'", ";", "O", "<<", "\"\\t.weak_definition\\t\"", "<<", "CurrentFnName", "<<", "'\\n'", ";", "break", ";", "}", "printVisibility", "(", "CurrentFnName", ",", "F", "->", "getVisibility", "(", ")", ")", ";", "EmitAlignment", "(", "F", "->", "hasFnAttr", "(", "Attribute", "::", "OptimizeForSize", ")", "?", "2", ":", "4", ",", "F", ")", ";", "O", "<<", "CurrentFnName", "<<", "\":\\n\"", ";", "DW", "->", "BeginFunction", "(", "&", "MF", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "if", "(", "++", "I", "==", "MF", ".", "end", "(", ")", "&&", "MF", ".", "front", "(", ")", ".", "empty", "(", ")", ")", "O", "<<", "\"\\tnop\\n\"", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "MF", ".", "begin", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ",", "VerboseAsm", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "IE", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "IE", ";", "++", "II", ")", "{", "printMachineInstruction", "(", "II", ")", ";", "}", "}", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "DW", "->", "EndFunction", "(", "&", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"\\n\\n\"", "0", "\"Unknown linkage type!\"", "\"\\t.globl\\t\"", "\"\\t.globl\\t\"", "\"\\t.weak_definition\\t\"", "2", "4", "\":\\n\"", "\"\\tnop\\n\"" ]

[]

[ "<s>", "int", "avr_simple_epilogue", "(", "void", ")", "{", "return", "(", "!", "frame_pointer_needed", "&&", "get_frame_size", "(", ")", "==", "0", "&&", "avr_outgoing_args_size", "(", ")", "==", "0", "&&", "avr_regs_to_save", "(", "NULL", ")", "==", "0", "&&", "!", "cfun", "->", "machine", "->", "is_interrupt", "&&", "!", "cfun", "->", "machine", "->", "is_signal", "&&", "!", "cfun", "->", "machine", "->", "is_naked", "&&", "!", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "function", "epilogue", "is", "just", "a", "single", "``", "ret", "''", "." ]

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

[]

[ "<s>", "bool", "sh_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "sh_cfun_interrupt_handler_p", "(", ")", "&&", "!", "df_regs_ever_live_p", "(", "new_reg", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "old_reg", "can", "be", "renamed", "to", "register", "new_reg", "." ]

[ "sh" ]

[]

[ "<s>", "static", "int", "alpha_multipass_dfa_lookahead", "(", "void", ")", "{", "return", "(", "alpha_tune", "==", "PROCESSOR_EV6", "?", "4", ":", "2", ")", ";", "}", "</s>" ]

[ "How", "many", "alternative", "schedules", "to", "try", ".", "This", "should", "be", "as", "wide", "as", "the", "scheduling", "freedom", "in", "the", "DFA", ",", "but", "no", "wider", ".", "Making", "this", "value", "too", "large", "results", "extra", "work", "for", "the", "scheduler", ".", "For", "EV4", ",", "loads", "can", "be", "issued", "to", "either", "IB0", "or", "IB1", ",", "thus", "we", "have", "2", "alternative", "schedules", ".", "For", "EV5", ",", "we", "can", "choose", "between", "E0/E1", "and", "FA/FM", ".", "For", "EV6", ",", "an", "arithmetic", "insn", "can", "be", "issued", "to", "U0/U1/L0/L1", "." ]

[ "alpha", "4", "2" ]

[]

[ "<s>", "bool", "MipsTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "MipsSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "useSmallSection", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "isTargetNaCl", "(", ")", ")", "return", "false", ";", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "!", "Kind", ".", "isBSS", "(", ")", "&&", "!", "Kind", ".", "isDataRel", "(", ")", ")", "return", "false", ";", "if", "(", "Kind", ".", "isMergeable1ByteCString", "(", ")", ")", "return", "false", ";", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "TM", ".", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

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

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getCallInstrCost", "(", "Function", "*", "F", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ")", "{", "return", "BaseT", "::", "getCallInstrCost", "(", "F", ",", "RetTy", ",", "Tys", ")", ";", "}", "</s>" ]

[ "Compute", "a", "cost", "of", "the", "given", "call", "instruction", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "UPTInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "UPT", "::", "LDR", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "UPT", "UPT", "UPT::LDR", "0" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "ix86_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "f", ";", "f", "=", "ggc_alloc_cleared", "(", "sizeof", "(", "struct", "machine_function", ")", ")", ";", "f", "->", "use_fast_prologue_epilogue_nregs", "=", "-", "1", ";", "return", "f", ";", "}", "</s>" ]

[ "Clear", "stack", "slot", "assignments", "remembered", "from", "previous", "functions", ".", "This", "is", "called", "from", "INIT_EXPANDERS", "once", "before", "RTL", "is", "emitted", "for", "each", "function", "." ]

[ "i386", "1" ]

[]

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

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

[ "AMDGPU", "256", "\"+promote-alloca,+load-store-opt,+enable-ds128,+sram-ecc,+xnack,\"", "\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", "\"+enable-prt-strict-null,\"", "\"+wavefrontsize\"", "\"wavefrontsize16\"", "\"-wavefrontsize16,\"", "\"wavefrontsize32\"", "\"-wavefrontsize32,\"", "\"wavefrontsize64\"", "\"-wavefrontsize64,\"", "AMDGPU", "\"flat-for-global\"", "0", "4", "0", "32", "0", "32768", "0", "5", "AMDGPU", "\"+xnack\"", "AMDGPU::FeatureXNACK", "AMDGPU::FeatureSRAMECC" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Replace loads/stores with library calls\"", ";", "}", "</s>" ]

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

[ "TVM", "\"Replace loads/stores with library calls\"" ]

[]

[ "<s>", "bool", "SparcAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SmallVector", "<", "MCInst", ",", "8", ">", "Instructions", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Instructions", ".", "push_back", "(", "Inst", ")", ";", "break", ";", "case", "SP", "::", "SET", ":", "expandSET", "(", "Inst", ",", "IDLoc", ",", "Instructions", ")", ";", "break", ";", "}", "for", "(", "const", "MCInst", "&", "I", ":", "Instructions", ")", "{", "Out", ".", "EmitInstruction", "(", "I", ",", "STI", ")", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "SparcOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction mnemonic\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "8", "SP::SET", "\"instruction requires a CPU feature not currently enabled\"", "0ULL", "\"too few operands for instruction\"", "Sparc", "\"invalid operand for instruction\"", "\"invalid instruction mnemonic\"", "\"Implement any new match types added!\"" ]

[]