Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "int", "arm_compute_static_chain_stack_bytes", "(", "void", ")", "{", "if", "(", "cfun", "->", "machine", "->", "static_chain_stack_bytes", "!=", "-", "1", ")", "return", "cfun", "->", "machine", "->", "static_chain_stack_bytes", ";", "if", "(", "IS_NESTED", "(", "arm_current_func_type", "(", ")", ")", "&&", "(", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "TARGET_ARM", ")", "||", "(", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", "||", "flag_stack_clash_protection", ")", "&&", "!", "df_regs_ever_live_p", "(", "LR_REGNUM", ")", ")", ")", "&&", "arm_r3_live_at_start_p", "(", ")", "&&", "crtl", "->", "args", ".", "pretend_args_size", "==", "0", ")", "return", "4", ";", "return", "0", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "bytes", "used", "to", "store", "the", "static", "chain", "register", "on", "the", "stack", ",", "above", "the", "stack", "frame", ".", "We", "need", "to", "know", "this", "accurately", "to", "get", "the", "alignment", "of", "the", "rest", "of", "the", "stack", "frame", "correct", "." ]

[ "arm", "1", "0", "4", "0" ]

[]

[ "<s>", "static", "bool", "characterize_address", "(", "rtx", "x", ",", "rtx", "*", "base", ",", "rtx", "*", "index", ",", "rtx", "*", "addend", ")", "{", "*", "base", "=", "NULL_RTX", ";", "*", "index", "=", "NULL_RTX", ";", "*", "addend", "=", "NULL_RTX", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNS_ES_ADDR", ")", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "{", "*", "base", "=", "x", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "*", "addend", "=", "x", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "*", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "x", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "*", "base", ")", "==", "SUBREG", ")", "{", "if", "(", "GET_MODE", "(", "*", "base", ")", "==", "HImode", "&&", "GET_MODE", "(", "XEXP", "(", "*", "base", ",", "0", ")", ")", "==", "SImode", "&&", "GET_CODE", "(", "XEXP", "(", "*", "base", ",", "0", ")", ")", "==", "REG", ")", "{", "*", "base", "=", "gen_rtx_REG", "(", "HImode", ",", "REGNO", "(", "XEXP", "(", "*", "base", ",", "0", ")", ")", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "*", "base", ")", "!=", "REG", "&&", "GET_CODE", "(", "x", ")", "==", "REG", ")", "{", "rtx", "tmp", "=", "*", "base", ";", "*", "base", "=", "x", ";", "x", "=", "tmp", ";", "}", "if", "(", "GET_CODE", "(", "*", "base", ")", "!=", "REG", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTEND", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", ")", "{", "*", "index", "=", "XEXP", "(", "x", ",", "0", ")", ";", "return", "false", ";", "}", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "CONST_INT", ")", "{", "*", "addend", "=", "x", ";", "return", "true", ";", "}", "case", "MEM", ":", "case", "REG", ":", "return", "false", ";", "case", "SUBREG", ":", "switch", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "CONST_INT", ":", "*", "addend", "=", "x", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "CONST_INT", ":", "*", "addend", "=", "x", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Break", "down", "an", "address", "RTX", "into", "its", "component", "base/index/addend", "portions", "and", "return", "TRUE", "if", "the", "address", "is", "of", "a", "valid", "form", ",", "else", "FALSE", "." ]

[ "rl78", "1", "0", "1", "0", "1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SparcRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "Subtarget", ".", "is64Bit", "(", ")", "?", "&", "SP", "::", "I64RegsRegClass", ":", "&", "SP", "::", "IntRegsRegClass", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::I64RegsRegClass", "SP::IntRegsRegClass" ]

[]

[ "<s>", "void", "M88kRegisterBankInfo", "::", "applyMappingImpl", "(", "const", "OperandsMapper", "&", "OpdMapper", ")", "const", "{", "return", "applyDefaultMapping", "(", "OpdMapper", ")", ";", "}", "</s>" ]

[ "See", "RegisterBankInfo", ":", ":applyMapping", "." ]

[ "M88k", "M88k" ]

[]

[ "<s>", "unsigned", "getOccupancyWithLocalMemSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "getOccupancyWithLocalMemSize", "(", "MFI", "->", "getLDSSize", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ")", ";", "}", "</s>" ]

[ "Inverse", "of", "getMaxLocalMemWithWaveCount", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "MipsLongBranch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "MipsSubtarget", "&", "STI", "=", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "F", ".", "getSubtarget", "(", ")", ")", ";", "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "TargetMachine", "&", "TM", "=", "F", ".", "getTarget", "(", ")", ";", "IsPIC", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "ABI", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ";", "LongBranchSeqSize", "=", "IsPIC", "?", "(", "(", "ABI", ".", "IsN64", "(", ")", "||", "STI", ".", "isTargetNaCl", "(", ")", ")", "?", "10", ":", "9", ")", ":", "(", "STI", ".", "hasMips32r6", "(", ")", "?", "1", ":", "2", ")", ";", "if", "(", "STI", ".", "inMips16Mode", "(", ")", "||", "!", "STI", ".", "enableLongBranchPass", "(", ")", ")", "return", "false", ";", "if", "(", "IsPIC", "&&", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ".", "IsO32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVectorImpl", "<", "MBBInfo", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "Br", "||", "I", "->", "HasLongBranch", ")", "continue", ";", "int", "ShVal", "=", "STI", ".", "inMicroMipsMode", "(", ")", "?", "2", ":", "4", ";", "int64_t", "Offset", "=", "computeOffset", "(", "I", "->", "Br", ")", "/", "ShVal", ";", "if", "(", "STI", ".", "isTargetNaCl", "(", ")", ")", "{", "Offset", "*=", "2", ";", "}", "if", "(", "!", "ForceLongBranch", "&&", "isInt", "<", "16", ">", "(", "Offset", ")", ")", "continue", ";", "I", "->", "HasLongBranch", "=", "true", ";", "I", "->", "Size", "+=", "LongBranchSeqSize", "*", "4", ";", "++", "LongBranches", ";", "EverMadeChange", "=", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "!", "EverMadeChange", ")", "return", "true", ";", "if", "(", "IsPIC", ")", "{", "uint64_t", "Address", "=", "0", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "Address", "+=", "I", "->", "Size", ",", "++", "I", ")", "I", "->", "Address", "=", "Address", ";", "}", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "HasLongBranch", ")", "expandToLongBranch", "(", "*", "I", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "10", "9", "Mips", "1", "2", "Mips", "Mips", "Mips", "Mips", "2", "4", "2", "16", "4", "0" ]

[]

[ "<s>", "const", "char", "*", "TPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "(", "TPCISD", "::", "FPOR", ")", ":", "return", "\"TPC::FPOR\"", ";", "case", "(", "TPCISD", "::", "FPAND", ")", ":", "return", "\"TPC::FPAND\"", ";", "case", "(", "TPCISD", "::", "FPXOR", ")", ":", "return", "\"TPC::FPXOR\"", ";", "case", "(", "TPCISD", "::", "FPNOT", ")", ":", "return", "\"TPC::FPNOT\"", ";", "case", "(", "TPCISD", "::", "MAC", ")", ":", "return", "\"TPC::MAC\"", ";", "case", "(", "TPCISD", "::", "FMAC", ")", ":", "return", "\"TPC::FMAC\"", ";", "case", "(", "TPCISD", "::", "MAX", ")", ":", "return", "\"TPC::MAX\"", ";", "case", "(", "TPCISD", "::", "MIN", ")", ":", "return", "\"TPC::MIN\"", ";", "case", "(", "TPCISD", "::", "FMAX", ")", ":", "return", "\"TPC::FMAX\"", ";", "case", "(", "TPCISD", "::", "FMIN", ")", ":", "return", "\"TPC::FMIN\"", ";", "case", "(", "TPCISD", "::", "INOT", ")", ":", "return", "\"TPC::INOT\"", ";", "case", "(", "TPCISD", "::", "FSRL", ")", ":", "return", "\"TPC::FSRL\"", ";", "case", "(", "TPCISD", "::", "FSHL", ")", ":", "return", "\"TPC::FSHL\"", ";", "case", "(", "TPCISD", "::", "FSRA", ")", ":", "return", "\"TPC::FSRA\"", ";", "case", "(", "TPCISD", "::", "HALT", ")", ":", "return", "\"halt\"", ";", "case", "(", "TPCISD", "::", "COND_MOV", ")", ":", "return", "\"TPC::COND_MOV\"", ";", "case", "(", "TPCISD", "::", "COND_MOV_INVERT", ")", ":", "return", "\"TPC::COND_MOV_INVERT\"", ";", "case", "(", "TPCISD", "::", "LD_G", ")", ":", "return", "\"TPC::LD_G\"", ";", "case", "(", "TPCISD", "::", "LD_G_INC", ")", ":", "return", "\"TPC::LD_G_INC\"", ";", "case", "(", "TPCISD", "::", "ST_G", ")", ":", "return", "\"TPC::ST_G\"", ";", "case", "(", "TPCISD", "::", "ST_G_INC", ")", ":", "return", "\"TPC::ST_G_INC\"", ";", "default", ":", "return", "nullptr", ";", "}", "}", "</s>" ]

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

[ "TPC", "TPC", "TPCISD::FPOR", "\"TPC::FPOR\"", "TPCISD::FPAND", "\"TPC::FPAND\"", "TPCISD::FPXOR", "\"TPC::FPXOR\"", "TPCISD::FPNOT", "\"TPC::FPNOT\"", "TPCISD::MAC", "\"TPC::MAC\"", "TPCISD::FMAC", "\"TPC::FMAC\"", "TPCISD::MAX", "\"TPC::MAX\"", "TPCISD::MIN", "\"TPC::MIN\"", "TPCISD::FMAX", "\"TPC::FMAX\"", "TPCISD::FMIN", "\"TPC::FMIN\"", "TPCISD::INOT", "\"TPC::INOT\"", "TPCISD::FSRL", "\"TPC::FSRL\"", "TPCISD::FSHL", "\"TPC::FSHL\"", "TPCISD::FSRA", "\"TPC::FSRA\"", "TPCISD::HALT", "\"halt\"", "TPCISD::COND_MOV", "\"TPC::COND_MOV\"", "TPCISD::COND_MOV_INVERT", "\"TPC::COND_MOV_INVERT\"", "TPCISD::LD_G", "\"TPC::LD_G\"", "TPCISD::LD_G_INC", "\"TPC::LD_G_INC\"", "TPCISD::ST_G", "\"TPC::ST_G\"", "TPCISD::ST_G_INC", "\"TPC::ST_G_INC\"" ]

[]

[ "<s>", "RISCVTargetLowering", "::", "ConstraintType", "RISCVTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'f'", ":", "return", "C_RegisterClass", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "return", "C_Immediate", ";", "case", "'A'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "RI5CY", "RISCV", "RISCV", "1", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "write_fn_proto_from_insn", "(", "std", "::", "stringstream", "&", "s", ",", "const", "char", "*", "name", ",", "rtx", "result", ",", "rtx", "pat", ")", "{", "char", "*", "replaced_dots", "=", "NULL", ";", "if", "(", "!", "name", ")", "{", "s", "<<", "\"\\t.callprototype \"", ";", "name", "=", "\"_\"", ";", "}", "else", "{", "const", "char", "*", "replacement", "=", "nvptx_name_replacement", "(", "name", ")", ";", "if", "(", "replacement", "!=", "name", ")", "name", "=", "replacement", ";", "else", "{", "replaced_dots", "=", "nvptx_replace_dot", "(", "name", ")", ";", "if", "(", "replaced_dots", ")", "name", "=", "replaced_dots", ";", "}", "write_fn_marker", "(", "s", ",", "false", ",", "true", ",", "name", ")", ";", "s", "<<", "\"\\t.extern .func \"", ";", "}", "if", "(", "result", "!=", "NULL_RTX", ")", "write_return_mode", "(", "s", ",", "true", ",", "GET_MODE", "(", "result", ")", ")", ";", "s", "<<", "name", ";", "if", "(", "replaced_dots", ")", "XDELETE", "(", "replaced_dots", ")", ";", "int", "arg_end", "=", "XVECLEN", "(", "pat", ",", "0", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "arg_end", ";", "i", "++", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ",", "0", ")", ")", ";", "write_arg_mode", "(", "s", ",", "-", "1", ",", "i", "-", "1", ",", "mode", ")", ";", "}", "if", "(", "arg_end", "!=", "1", ")", "s", "<<", "\")\"", ";", "s", "<<", "\";\\n\"", ";", "}", "</s>" ]

[ "Construct", "a", "function", "declaration", "from", "a", "call", "insn", ".", "This", "can", "be", "necessary", "for", "two", "reasons", "-", "either", "we", "have", "an", "indirect", "call", "which", "requires", "a", ".callprototype", "declaration", ",", "or", "we", "have", "a", "libcall", "generated", "by", "emit_library_call", "for", "which", "no", "decl", "exists", "." ]

[ "nvptx", "\"\\t.callprototype \"", "\"_\"", "\"\\t.extern .func \"", "0", "1", "0", "0", "1", "1", "1", "\")\"", "\";\\n\"" ]

[]

[ "<s>", "static", "bool", "sparc_can_output_mi_thunk", "(", "const_tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "vcall_offset", ",", "const_tree", "function", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "vcall_offset", ">=", "-", "32768", "||", "!", "fixed_regs", "[", "5", "]", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "sparc_output_mi_thunk", "would", "be", "able", "to", "output", "the", "assembler", "code", "for", "the", "thunk", "function", "specified", "by", "the", "arguments", "it", "is", "passed", ",", "and", "false", "otherwise", "." ]

[ "sparc", "32768", "5" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerCRSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "bool", "LP64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "unsigned", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "MFOCRF8", ":", "PPC", "::", "MFOCRF", ")", ",", "Reg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ")", ")", ";", "if", "(", "SrcReg", "!=", "PPC", "::", "CR0", ")", "{", "unsigned", "Reg1", "=", "Reg", ";", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "RLWINM8", ":", "PPC", "::", "RLWINM", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg1", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "getEncodingValue", "(", "SrcReg", ")", "*", "4", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "31", ")", ";", "}", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "STW8", ":", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ",", "FrameIndex", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerCRSpilling", "-", "Generate", "the", "code", "for", "spilling", "a", "CR", "register", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "0", "PPC::MFOCRF8", "PPC::MFOCRF", "0", "PPC::CR0", "PPC::RLWINM8", "PPC::RLWINM", "4", "0", "31", "PPC::STW8", "PPC::STW" ]

[]

[ "<s>", "RegisterRef", "PhysicalRegisterInfo", "::", "normalize", "(", "RegisterRef", "RR", ")", "const", "{", "if", "(", "PhysicalRegisterInfo", "::", "isRegMaskId", "(", "RR", ".", "Reg", ")", ")", "return", "RR", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfos", "[", "RR", ".", "Reg", "]", ".", "RegClass", ";", "LaneBitmask", "RCMask", "=", "RC", "!=", "nullptr", "?", "RC", "->", "LaneMask", ":", "LaneBitmask", "(", "0x00000001", ")", ";", "LaneBitmask", "Common", "=", "RR", ".", "Mask", "&", "RCMask", ";", "RegisterId", "SuperReg", "=", "RegInfos", "[", "RR", ".", "Reg", "]", ".", "MaxSuper", ";", "uint32_t", "Sub", "=", "TRI", ".", "getSubRegIndex", "(", "SuperReg", ",", "RR", ".", "Reg", ")", ";", "LaneBitmask", "SuperMask", "=", "TRI", ".", "composeSubRegIndexLaneMask", "(", "Sub", ",", "Common", ")", ";", "return", "RegisterRef", "(", "SuperReg", ",", "SuperMask", ")", ";", "}", "</s>" ]

[ "Weight", "normalization", "function", "." ]

[ "Hexagon", "0x00000001" ]

[]

[ "<s>", "MachineInstr", "*", "AArch64InstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "int", "FrameIndex", ",", "LiveIntervals", "*", "LIS", ")", "const", "{", "if", "(", "MI", "->", "isCopy", "(", ")", ")", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "SrcReg", "==", "AArch64", "::", "SP", "&&", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DstReg", ")", ")", "{", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "DstReg", ",", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "return", "nullptr", ";", "}", "if", "(", "DstReg", "==", "AArch64", "::", "SP", "&&", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", ")", "{", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "return", "nullptr", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "AArch64", "AArch64", "0", "1", "AArch64::SP", "AArch64::GPR64RegClass", "AArch64::SP", "AArch64::GPR64RegClass" ]

[]

[ "<s>", "static", "rtx", "loongarch_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "loongarch_function_value_1", "(", "valtype", ",", "fn_decl_or_type", ",", "VOIDmode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "Z80oldInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Z80old", "::", "OR8ar", ":", "SrcReg", "=", "Z80old", "::", "A", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "SrcReg", ")", "{", "return", "false", ";", "}", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "break", ";", "case", "Z80old", "::", "CP8ai", ":", "case", "Z80old", "::", "SUB8ai", ":", "SrcReg", "=", "Z80old", "::", "A", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "CmpValue", "=", "0", ";", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isImm", "(", ")", ")", "{", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "}", "break", ";", "case", "Z80old", "::", "CP8ar", ":", "case", "Z80old", "::", "SUB8ar", ":", "SrcReg", "=", "Z80old", "::", "A", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "CmpValue", "=", "0", ";", "break", ";", "case", "Z80old", "::", "CP8ap", ":", "case", "Z80old", "::", "CP8ao", ":", "case", "Z80old", "::", "SUB8ap", ":", "case", "Z80old", "::", "SUB8ao", ":", "SrcReg", "=", "Z80old", "::", "A", ";", "SrcReg2", "=", "CmpMask", "=", "CmpValue", "=", "0", ";", "break", ";", "}", "MachineBasicBlock", "::", "const_reverse_iterator", "I", "=", "MI", ",", "E", "=", "MI", ".", "getParent", "(", ")", "->", "rend", "(", ")", ";", "while", "(", "++", "I", "!=", "E", "&&", "I", "->", "isFullCopy", "(", ")", ")", "for", "(", "unsigned", "*", "Reg", ":", "{", "&", "SrcReg", ",", "&", "SrcReg2", "}", ")", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "*", "Reg", ")", "&&", "*", "Reg", "==", "I", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "{", "*", "Reg", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "Z80old", "Z80old", "Z80old::OR8ar", "Z80old::A", "1", "0", "0", "0", "Z80old::CP8ai", "Z80old::SUB8ai", "Z80old::A", "0", "0", "0", "0", "0", "Z80old::CP8ar", "Z80old::SUB8ar", "Z80old::A", "0", "0", "Z80old::CP8ap", "Z80old::CP8ao", "Z80old::SUB8ap", "Z80old::SUB8ao", "Z80old::A", "0", "0", "1" ]

[]

[ "<s>", "unsigned", "VideocoreRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "VC", "::", "R23", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "VC::R23" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "Mask", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "return", "isStridedLoad", "(", "Mask", ")", "!=", "StridedLoadKind", "::", "NoPattern", ";", "return", "true", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Prepare Exception\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Prepare Exception\"" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "MCInst", "Inst", ";", "unsigned", "ErrorInfo", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ")", ")", ";", "forwardITPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "unsigned", "Mask", "=", "1", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "(", "sizeof", "(", "ErrorInfo", ")", "*", "8", "-", "1", ")", ";", "++", "i", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "1", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ",", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "0", "]", ")", "->", "getLocRange", "(", ")", ")", ";", "case", "Match_ConversionFail", ":", "return", "true", ";", "case", "Match_RequiresNotITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"flag setting instruction only valid outside IT block\"", ")", ";", "case", "Match_RequiresITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction only valid inside IT block\"", ")", ";", "case", "Match_RequiresV6", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires ARMv6 or later\"", ")", ";", "case", "Match_RequiresThumb2", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires Thumb2\"", ")", ";", "case", "Match_ImmRange0_15", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate operand must be in the range [0,15]\"", ")", ";", "}", "}", "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", "." ]

[ "ARM", "ARM", "ARM::ITasm", "\"Unknown missing feature!\"", "\"instruction requires:\"", "1", "0", "8", "1", "\" \"", "1", "0U", "\"too few operands for instruction\"", "ARM", "\"invalid operand for instruction\"", "\"invalid instruction\"", "ARM", "0", "\"flag setting instruction only valid outside IT block\"", "\"instruction only valid inside IT block\"", "\"instruction variant requires ARMv6 or later\"", "\"instruction variant requires Thumb2\"", "ARM", "\"immediate operand must be in the range [0,15]\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "hexagon_L2_loadrd_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadri_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadrh_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadruh_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadrb_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadrub_pbr", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "auto", "&", "DL", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "auto", "&", "Cont", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getParent", "(", ")", "->", "getContext", "(", ")", ";", "Type", "*", "ElTy", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getReturnType", "(", ")", "->", "getStructElementType", "(", "0", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "ElTy", ")", ";", "llvm", "::", "Value", "*", "BasePtrVal", "=", "I", ".", "getOperand", "(", "0", ")", ";", "Info", ".", "ptrVal", "=", "getUnderLyingObjectForBrevLdIntr", "(", "BasePtrVal", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "DL", ".", "getABITypeAlignment", "(", "Info", ".", "memVT", ".", "getTypeForEVT", "(", "Cont", ")", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "hexagon_V6_vgathermw", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermw_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermh", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermh_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhw", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhw_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermwq", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermwq_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhq", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhq_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhwq", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhwq_128B", ":", "{", "const", "Module", "&", "M", "=", "*", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Type", "*", "VecTy", "=", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "VecTy", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "M", ".", "getDataLayout", "(", ")", ".", "getTypeAllocSizeInBits", "(", "VecTy", ")", "/", "8", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Intrinsic::hexagon_L2_loadrd_pbr", "Intrinsic::hexagon_L2_loadri_pbr", "Intrinsic::hexagon_L2_loadrh_pbr", "Intrinsic::hexagon_L2_loadruh_pbr", "Intrinsic::hexagon_L2_loadrb_pbr", "Intrinsic::hexagon_L2_loadrub_pbr", "ISD::INTRINSIC_W_CHAIN", "0", "MVT::getVT", "0", "0", "Intrinsic::hexagon_V6_vgathermw", "Intrinsic::hexagon_V6_vgathermw_128B", "Intrinsic::hexagon_V6_vgathermh", "Intrinsic::hexagon_V6_vgathermh_128B", "Intrinsic::hexagon_V6_vgathermhw", "Intrinsic::hexagon_V6_vgathermhw_128B", "Intrinsic::hexagon_V6_vgathermwq", "Intrinsic::hexagon_V6_vgathermwq_128B", "Intrinsic::hexagon_V6_vgathermhq", "Intrinsic::hexagon_V6_vgathermhq_128B", "Intrinsic::hexagon_V6_vgathermhwq", "Intrinsic::hexagon_V6_vgathermhwq_128B", "ISD::INTRINSIC_W_CHAIN", "1", "MVT::getVT", "0", "0", "8" ]

[]

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

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

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

[]

[ "<s>", "void", "OR1KFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "StackAlign", "=", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "?", "MFI", "->", "getMaxAlignment", "(", ")", ":", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "RoundUpToAlignment", "(", "maxCallFrameSize", ",", "StackAlign", ")", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "if", "(", "!", "(", "hasReservedCallFrame", "(", "MF", ")", "&&", "MFI", "->", "adjustsStack", "(", ")", ")", ")", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "RoundUpToAlignment", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "unsigned", "*", "OpcodesForSpill", "=", "getLoadOpcodesForSpillArray", "(", ")", ";", "const", "unsigned", "*", "End", "=", "OpcodesForSpill", "+", "SOK_LastOpcodeSpill", ";", "if", "(", "End", "!=", "std", "::", "find", "(", "OpcodesForSpill", ",", "End", ",", "Opcode", ")", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

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

[]

[ "<s>", "bool", "AMDGPUInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ",", "CodeGenCoverage", "&", "CoverageInfo", ")", "const", "{", "if", "(", "!", "isPreISelGenericOpcode", "(", "I", ".", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCOPY", "(", "I", ")", ";", "return", "true", ";", "}", "switch", "(", "I", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "return", "selectG_ADD", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTTOPTR", ":", "case", "TargetOpcode", "::", "G_BITCAST", ":", "return", "selectCOPY", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "case", "TargetOpcode", "::", "G_FCONSTANT", ":", "return", "selectG_CONSTANT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT", ":", "return", "selectG_EXTRACT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_GEP", ":", "return", "selectG_GEP", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "return", "selectG_IMPLICIT_DEF", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INSERT", ":", "return", "selectG_INSERT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC", ":", "return", "selectG_INTRINSIC", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_W_SIDE_EFFECTS", ":", "return", "selectG_INTRINSIC_W_SIDE_EFFECTS", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_ICMP", ":", "return", "selectG_ICMP", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "if", "(", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ")", "return", "true", ";", "return", "selectG_LOAD", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_SELECT", ":", "return", "selectG_SELECT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "selectG_STORE", "(", "I", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

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

[]

[ "<s>", "void", "HvxSelector", "::", "select", "(", "SDNode", "*", "ISelN", ")", "{", "assert", "(", "ISelN", "->", "getOpcode", "(", ")", "==", "HexagonISD", "::", "ISEL", ")", ";", "SDNode", "*", "N0", "=", "ISelN", "->", "getOperand", "(", "0", ")", ".", "getNode", "(", ")", ";", "if", "(", "N0", "->", "isMachineOpcode", "(", ")", ")", "{", "ISel", ".", "ReplaceNode", "(", "ISelN", ",", "N0", ")", ";", "return", ";", "}", "DAG", ".", "RemoveDeadNodes", "(", ")", ";", "SetVector", "<", "SDNode", "*", ">", "SubNodes", ",", "TmpQ", ";", "std", "::", "map", "<", "SDNode", "*", ",", "unsigned", ">", "NumOps", ";", "auto", "IsISelN", "=", "[", "]", "(", "SDNode", "*", "T", ")", "{", "return", "T", "->", "getOpcode", "(", ")", "==", "HexagonISD", "::", "ISEL", ";", "}", ";", "if", "(", "llvm", "::", "all_of", "(", "N0", "->", "uses", "(", ")", ",", "IsISelN", ")", ")", "SubNodes", ".", "insert", "(", "N0", ")", ";", "auto", "InSubNodes", "=", "[", "&", "SubNodes", "]", "(", "SDNode", "*", "T", ")", "{", "return", "SubNodes", ".", "count", "(", "T", ")", ";", "}", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "SubNodes", ".", "size", "(", ")", ";", "++", "I", ")", "{", "SDNode", "*", "S", "=", "SubNodes", "[", "I", "]", ";", "unsigned", "OpN", "=", "0", ";", "for", "(", "SDValue", "Op", ":", "S", "->", "ops", "(", ")", ")", "{", "SDNode", "*", "O", "=", "Op", ".", "getNode", "(", ")", ";", "if", "(", "llvm", "::", "all_of", "(", "O", "->", "uses", "(", ")", ",", "InSubNodes", ")", ")", "{", "SubNodes", ".", "insert", "(", "O", ")", ";", "++", "OpN", ";", "}", "}", "NumOps", ".", "insert", "(", "{", "S", ",", "OpN", "}", ")", ";", "if", "(", "OpN", "==", "0", ")", "TmpQ", ".", "insert", "(", "S", ")", ";", "}", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "TmpQ", ".", "size", "(", ")", ";", "++", "I", ")", "{", "SDNode", "*", "S", "=", "TmpQ", "[", "I", "]", ";", "for", "(", "SDNode", "*", "U", ":", "S", "->", "uses", "(", ")", ")", "{", "if", "(", "U", "==", "ISelN", ")", "continue", ";", "auto", "F", "=", "NumOps", ".", "find", "(", "U", ")", ";", "assert", "(", "F", "!=", "NumOps", ".", "end", "(", ")", ")", ";", "if", "(", "F", "->", "second", ">", "0", "&&", "!", "--", "F", "->", "second", ")", "TmpQ", ".", "insert", "(", "F", "->", "first", ")", ";", "}", "}", "ISel", ".", "ReplaceNode", "(", "ISelN", ",", "N0", ")", ";", "assert", "(", "SubNodes", ".", "size", "(", ")", "==", "TmpQ", ".", "size", "(", ")", ")", ";", "NullifyingVector", "<", "decltype", "(", "TmpQ", ")", "::", "vector_type", ">", "Queue", "(", "TmpQ", ".", "takeVector", "(", ")", ")", ";", "Deleter", "DUQ", "(", "DAG", ",", "Queue", ")", ";", "for", "(", "SDNode", "*", "S", ":", "reverse", "(", "Queue", ")", ")", "{", "if", "(", "S", "==", "nullptr", ")", "continue", ";", "DEBUG_WITH_TYPE", "(", "\"isel\"", ",", "{", "dbgs", "(", ")", "<<", "\"HVX selecting: \"", ";", "S", "->", "dump", "(", "&", "DAG", ")", ";", "}", ")", ";", "ISel", ".", "Select", "(", "S", ")", ";", "}", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "Hexagon", "HexagonISD::ISEL", "0", "HexagonISD::ISEL", "0", "0", "0", "0", "0", "\"isel\"", "\"HVX selecting: \"" ]

[]

[ "<s>", "bool", "GBZ80FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "GBZ80", "GB" ]

[]

[ "<s>", "enum", "rtx_code", "ix86_fp_compare_code_to_integer", "(", "enum", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "GT", ":", "return", "GTU", ";", "case", "GE", ":", "return", "GEU", ";", "case", "ORDERED", ":", "case", "UNORDERED", ":", "return", "code", ";", "case", "UNEQ", ":", "return", "EQ", ";", "case", "UNLT", ":", "return", "LTU", ";", "case", "UNLE", ":", "return", "LEU", ";", "case", "LTGT", ":", "return", "NE", ";", "default", ":", "return", "UNKNOWN", ";", "}", "}", "</s>" ]

[ "Convert", "comparison", "codes", "we", "use", "to", "represent", "FP", "comparison", "to", "integer", "code", "that", "will", "result", "in", "proper", "branch", ".", "Return", "UNKNOWN", "if", "no", "such", "code", "is", "available", "." ]

[ "i386" ]

[]

[ "<s>", "unsigned", "PPCDispatchGroupSBHazardRecognizer", "::", "PreEmitNoops", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "isLoadAfterStore", "(", "SU", ")", "&&", "CurSlots", "<", "6", ")", "{", "unsigned", "Mcpu", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getMcpu", "(", ")", ";", "if", "(", "Mcpu", "==", "PPC", "::", "MCPU_PWR6", "||", "Mcpu", "==", "PPC", "::", "MCPU_PWR7", "||", "Mcpu", "==", "PPC", "::", "MCPU_PWR8", "||", "Mcpu", "==", "PPC", "::", "MCPU_PWR9", ")", "return", "1", ";", "return", "5", "-", "CurSlots", ";", "}", "return", "ScoreboardHazardRecognizer", "::", "PreEmitNoops", "(", "SU", ")", ";", "}", "</s>" ]

[ "PreEmitNoops", "-", "This", "callback", "is", "invoked", "prior", "to", "emitting", "an", "instruction", "." ]

[ "PowerPC", "PPC", "6", "PPC", "PPC::MCPU_PWR6", "PPC::MCPU_PWR7", "PPC::MCPU_PWR8", "PPC::MCPU_PWR9", "1", "5" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createPPCISelDag", "(", "getPPCTargetMachine", "(", ")", ")", ")", ";", "if", "(", "!", "DisableCTRLoops", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCCTRLoopsVerify", "(", ")", ")", ";", "addPass", "(", "createPPCVSXCopyPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "postOffset", "(", "Align", "Alignment", "=", "Align", "::", "None", "(", ")", ")", "const", "{", "unsigned", "PO", "=", "Offset", "+", "Size", ";", "const", "Align", "PA", "=", "std", "::", "max", "(", "PostAlign", ",", "Alignment", ")", ";", "if", "(", "PA", "==", "Align", "::", "None", "(", ")", ")", "return", "PO", ";", "return", "PO", "+", "UnknownPadding", "(", "PA", ",", "internalKnownBits", "(", ")", ")", ";", "}", "</s>" ]

[ "Compute", "the", "offset", "immediately", "following", "this", "block", "." ]

[ "ARM" ]

[]

[ "<s>", "virtual", "void", "emitSparcRegisterIgnore", "(", "unsigned", "reg", ")", "{", "}", "</s>" ]

[ "Emit", "``", ".register", "<", "reg", ">", ",", "#", "ignore", "''", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "riscv_set_return_address", "(", "rtx", "address", ",", "rtx", "scratch", ")", "{", "rtx", "slot_address", ";", "gcc_assert", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", ",", "RETURN_ADDR_REGNUM", ")", ")", ";", "slot_address", "=", "riscv_add_offset", "(", "scratch", ",", "stack_pointer_rtx", ",", "cfun", "->", "machine", "->", "frame", ".", "gp_sp_offset", ")", ";", "riscv_emit_move", "(", "gen_frame_mem", "(", "GET_MODE", "(", "address", ")", ",", "slot_address", ")", ",", "address", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "change", "the", "current", "function", "'s", "return", "address", "to", "ADDRESS", ".", "SCRATCH", "is", "available", "as", "a", "scratch", "register", ",", "if", "needed", ".", "ADDRESS", "and", "SCRATCH", "are", "both", "word-mode", "GPRs", "." ]

[ "riscv" ]

[]

[ "<s>", "TargetPassConfig", "*", "HexagonTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "HexagonPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "schedNode", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ")", "{", "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", "M88kPassConfig", "::", "addLegalizeMachineIR", "(", ")", "{", "addPass", "(", "new", "Legalizer", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "legalize", "pass", ",", "which", "converts", "the", "instruction", "sequence", "into", "one", "that", "can", "be", "selected", "by", "the", "target", "." ]

[ "M88k", "M88k" ]

[]

[ "<s>", "static", "void", "or1k_finish_atomic_subword", "(", "machine_mode", "mode", ",", "rtx", "o", ",", "rtx", "n", ",", "rtx", "shift", ")", "{", "n", "=", "expand_binop", "(", "SImode", ",", "lshr_optab", ",", "n", ",", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "emit_move_insn", "(", "o", ",", "gen_lowpart", "(", "mode", ",", "n", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "various", "atomic", "expanders", ".", "For", "sub-word", "operations", ",", "complete", "the", "operation", "by", "shifting", "result", "to", "the", "lsb", "of", "the", "SImode", "temporary", "and", "then", "extracting", "the", "result", "in", "MODE", "with", "a", "SUBREG", "." ]

[ "or1k", "1" ]

[]

[ "<s>", "void", "NVPTXInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "DestRC", "=", "MRI", ".", "getRegClass", "(", "DestReg", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "if", "(", "DestRC", "!=", "SrcRC", ")", "report_fatal_error", "(", "\"Attempted to created cross-class register copy\"", ")", ";", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int32RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "NVPTX", "::", "IMOV32rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int1RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "NVPTX", "::", "IMOV1rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float32RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "NVPTX", "::", "FMOV32rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int16RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "NVPTX", "::", "IMOV16rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int8RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "NVPTX", "::", "IMOV8rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int64RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "NVPTX", "::", "IMOV64rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float64RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "NVPTX", "::", "FMOV64rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "{", "llvm_unreachable", "(", "\"Bad register copy\"", ")", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"Attempted to created cross-class register copy\"", "NVPTX::Int32RegsRegClass", "NVPTX::IMOV32rr", "NVPTX::Int1RegsRegClass", "NVPTX::IMOV1rr", "NVPTX::Float32RegsRegClass", "NVPTX::FMOV32rr", "NVPTX::Int16RegsRegClass", "NVPTX::IMOV16rr", "NVPTX::Int8RegsRegClass", "NVPTX::IMOV8rr", "NVPTX::Int64RegsRegClass", "NVPTX::IMOV64rr", "NVPTX::Float64RegsRegClass", "NVPTX::FMOV64rr", "\"Bad register copy\"" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "TS", ".", "forbidModuleDirective", "(", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "if", "(", "InConstantPool", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "OutStreamer", "->", "EmitDataRegion", "(", "MCDR_DataRegionEnd", ")", ";", "InConstantPool", "=", "false", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "unsigned", "LabelId", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "unsigned", "CPIdx", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "if", "(", "!", "InConstantPool", ")", "{", "OutStreamer", "->", "EmitDataRegion", "(", "MCDR_DataRegion", ")", ";", "InConstantPool", "=", "true", ";", "}", "OutStreamer", "->", "EmitLabel", "(", "GetCPISymbol", "(", "LabelId", ")", ")", ";", "const", "MachineConstantPoolEntry", "&", "MCPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPIdx", "]", ";", "if", "(", "MCPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "EmitMachineConstantPoolValue", "(", "MCPE", ".", "Val", ".", "MachineCPVal", ")", ";", "else", "EmitGlobalConstant", "(", "MF", "->", "getDataLayout", "(", ")", ",", "MCPE", ".", "Val", ".", "ConstVal", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG64", ")", "{", "emitPseudoIndirectBranch", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", "->", "isPseudo", "(", ")", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", "&&", "!", "isLongBranchPseudo", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "&", "*", "I", ",", "TmpInst0", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst0", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Mips", "Mips", "Mips", "128", "Mips::CONSTPOOL_ENTRY", "Mips::CONSTPOOL_ENTRY", "0", "1", "Mips::PseudoReturn", "Mips::PseudoReturn64", "Mips::PseudoIndirectBranch", "Mips::PseudoIndirectBranch64", "Mips::TAILCALLREG", "Mips::TAILCALLREG64", "Mips", "\"Pseudo opcode found in EmitInstruction()\"" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "rtx", "index", ";", "int", "size", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "h8_reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "PRE_INC", ":", "fprintf", "(", "file", ",", "\"+%s\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_DEC", ":", "fprintf", "(", "file", ",", "\"%s-\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "fprintf", "(", "file", ",", "\"(\"", ")", ";", "index", "=", "h8300_get_index", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "VOIDmode", ",", "&", "size", ")", ";", "if", "(", "GET_CODE", "(", "index", ")", "==", "REG", ")", "{", "print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\",\"", ")", ";", "switch", "(", "size", ")", "{", "case", "0", ":", "print_operand_address", "(", "file", ",", "index", ")", ";", "break", ";", "case", "1", ":", "print_operand", "(", "file", ",", "index", ",", "'X'", ")", ";", "fputs", "(", "\".b\"", ",", "file", ")", ";", "break", ";", "case", "2", ":", "print_operand", "(", "file", ",", "index", ",", "'T'", ")", ";", "fputs", "(", "\".w\"", ",", "file", ")", ";", "break", ";", "case", "4", ":", "print_operand", "(", "file", ",", "index", ",", "'S'", ")", ";", "fputs", "(", "\".l\"", ",", "file", ")", ";", "break", ";", "}", "}", "else", "{", "print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "}", "fprintf", "(", "file", ",", "\")\"", ")", ";", "break", ";", "case", "CONST_INT", ":", "{", "int", "n", "=", "INTVAL", "(", "addr", ")", ";", "if", "(", "TARGET_H8300", ")", "n", "=", "(", "int", ")", "(", "short", ")", "n", ";", "fprintf", "(", "file", ",", "\"%d\"", ",", "n", ")", ";", "break", ";", "}", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "h8300", "\"%s\"", "\"-%s\"", "0", "\"%s+\"", "0", "\"+%s\"", "0", "\"%s-\"", "0", "\"(\"", "0", "1", "\",\"", "0", "1", "\".b\"", "2", "\".w\"", "4", "\".l\"", "0", "\"+\"", "1", "\")\"", "\"%d\"" ]

[]

[ "<s>", "void", "s390_split_access_reg", "(", "rtx", "reg", ",", "rtx", "*", "lo", ",", "rtx", "*", "hi", ")", "{", "gcc_assert", "(", "TARGET_64BIT", ")", ";", "gcc_assert", "(", "ACCESS_REG_P", "(", "reg", ")", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "reg", ")", "==", "DImode", ")", ";", "gcc_assert", "(", "!", "(", "REGNO", "(", "reg", ")", "&", "1", ")", ")", ";", "*", "lo", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "reg", ")", "+", "1", ")", ";", "*", "hi", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "reg", ")", ")", ";", "}", "</s>" ]

[ "Split", "DImode", "access", "register", "reference", "REG", "(", "on", "64-bit", ")", "into", "its", "constituent", "low", "and", "high", "parts", ",", "and", "store", "them", "into", "LO", "and", "HI", ".", "Note", "that", "gen_lowpart/", "gen_highpart", "can", "not", "be", "used", "as", "they", "assume", "all", "registers", "are", "word-sized", ",", "while", "our", "access", "registers", "have", "only", "half", "that", "size", "." ]

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

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyNullifyDebugValueLists", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "if", "(", "TM", "->", "Options", ".", "ExceptionModel", "==", "ExceptionHandling", "::", "Wasm", ")", "addPass", "(", "createWebAssemblyLateEHPrepare", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyMemIntrinsicResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyCFGSort", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "if", "(", "!", "WasmDisableExplicitLocals", ")", "addPass", "(", "createWebAssemblyExplicitLocals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "if", "(", "!", "WasmDisableExplicitLocals", ")", "addPass", "(", "createWebAssemblyDebugFixup", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyMCLowerPrePass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "sh2a_get_function_vector_number", "(", "rtx", "x", ")", "{", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "&&", "(", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "SYMBOL_FLAG_FUNCVEC_FUNCTION", ")", ")", "{", "tree", "t", "=", "SYMBOL_REF_DECL", "(", "x", ")", ";", "if", "(", "TREE_CODE", "(", "t", ")", "!=", "FUNCTION_DECL", ")", "return", "0", ";", "for", "(", "tree", "list", "=", "SH_ATTRIBUTES", "(", "t", ")", ";", "list", ";", "list", "=", "TREE_CHAIN", "(", "list", ")", ")", "if", "(", "is_attribute_p", "(", "\"function_vector\"", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "return", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "list", ")", ")", ")", ";", "return", "0", ";", "}", "else", "return", "0", ";", "}", "</s>" ]

[ "Returns", "the", "function", "vector", "number", ",", "if", "the", "attribute", "'function_vector", "'", "is", "assigned", ",", "otherwise", "returns", "zero", "." ]

[ "sh", "0", "\"function_vector\"", "0", "0" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MF", ".", "setHasWinCFI", "(", "false", ")", ";", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "STI", ".", "is64Bit", "(", ")", "||", "!", "MF", ".", "hasEHFunclets", "(", ")", "||", "classifyEHPersonality", "(", "Fn", "->", "getPersonalityFn", "(", ")", ")", "!=", "EHPersonality", "::", "MSVC_CXX", ")", "return", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "WinEHFuncInfo", "&", "EHInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "int64_t", "MinFixedObjOffset", "=", "-", "SlotSize", ";", "for", "(", "int", "I", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ";", "I", "<", "0", ";", "++", "I", ")", "MinFixedObjOffset", "=", "std", "::", "min", "(", "MinFixedObjOffset", ",", "MFI", ".", "getObjectOffset", "(", "I", ")", ")", ";", "for", "(", "WinEHTryBlockMapEntry", "&", "TBME", ":", "EHInfo", ".", "TryBlockMap", ")", "{", "for", "(", "WinEHHandlerType", "&", "H", ":", "TBME", ".", "HandlerArray", ")", "{", "int", "FrameIndex", "=", "H", ".", "CatchObj", ".", "FrameIndex", ";", "if", "(", "FrameIndex", "!=", "INT_MAX", ")", "{", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MinFixedObjOffset", "-=", "std", "::", "abs", "(", "MinFixedObjOffset", ")", "%", "Align", ";", "MinFixedObjOffset", "-=", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "MFI", ".", "setObjectOffset", "(", "FrameIndex", ",", "MinFixedObjOffset", ")", ";", "}", "}", "}", "MinFixedObjOffset", "-=", "std", "::", "abs", "(", "MinFixedObjOffset", ")", "%", "8", ";", "int64_t", "UnwindHelpOffset", "=", "MinFixedObjOffset", "-", "SlotSize", ";", "int", "UnwindHelpFI", "=", "MFI", ".", "CreateFixedObject", "(", "SlotSize", ",", "UnwindHelpOffset", ",", "false", ")", ";", "EHInfo", ".", "UnwindHelpFrameIdx", "=", "UnwindHelpFI", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MBBI", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV64mi32", ")", ")", ",", "UnwindHelpFI", ")", ".", "addImm", "(", "-", "2", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "8", "X86::MOV64mi32", "2" ]

[]

[ "<s>", "static", "void", "nvptx_file_start", "(", "void", ")", "{", "fputs", "(", "\"// BEGIN PREAMBLE\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.version\\t\"", ",", "asm_out_file", ")", ";", "fputs", "(", "ptx_version_to_string", "(", "(", "enum", "ptx_version", ")", "ptx_version_option", ")", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.target\\tsm_\"", ",", "asm_out_file", ")", ";", "fputs", "(", "sm_version_to_string", "(", "(", "enum", "ptx_isa", ")", "ptx_isa_option", ")", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\n\"", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.address_size %d\\n\"", ",", "GET_MODE_BITSIZE", "(", "Pmode", ")", ")", ";", "fputs", "(", "\"// END PREAMBLE\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_START", ".", "Write", "the", "kinds", "of", "things", "ptxas", "expects", "at", "the", "start", "of", "a", "file", "." ]

[ "nvptx", "\"// BEGIN PREAMBLE\\n\"", "\"\\t.version\\t\"", "\"\\n\"", "\"\\t.target\\tsm_\"", "\"\\n\"", "\"\\t.address_size %d\\n\"", "\"// END PREAMBLE\\n\"" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin_compare", "(", "enum", "mips_builtin_type", "builtin_type", ",", "enum", "insn_code", "icode", ",", "enum", "mips_fp_condition", "cond", ",", "rtx", "target", ",", "tree", "exp", ")", "{", "rtx", "offset", ",", "condition", ",", "cmp_result", ";", "if", "(", "target", "==", "0", "||", "GET_MODE", "(", "target", ")", "!=", "SImode", ")", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "cmp_result", "=", "mips_expand_builtin_compare_1", "(", "icode", ",", "cond", ",", "exp", ",", "call_expr_nargs", "(", "exp", ")", ")", ";", "switch", "(", "builtin_type", ")", "{", "case", "MIPS_BUILTIN_CMP_ALL", ":", "condition", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cmp_result", ",", "constm1_rtx", ")", ";", "return", "mips_builtin_branch_and_move", "(", "condition", ",", "target", ",", "const0_rtx", ",", "const1_rtx", ")", ";", "case", "MIPS_BUILTIN_CMP_UPPER", ":", "case", "MIPS_BUILTIN_CMP_LOWER", ":", "offset", "=", "GEN_INT", "(", "builtin_type", "==", "MIPS_BUILTIN_CMP_UPPER", ")", ";", "condition", "=", "gen_single_cc", "(", "cmp_result", ",", "offset", ")", ";", "return", "mips_builtin_branch_and_move", "(", "condition", ",", "target", ",", "const1_rtx", ",", "const0_rtx", ")", ";", "default", ":", "condition", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cmp_result", ",", "const0_rtx", ")", ";", "return", "mips_builtin_branch_and_move", "(", "condition", ",", "target", ",", "const1_rtx", ",", "const0_rtx", ")", ";", "}", "}", "</s>" ]

[ "Expand", "a", "comparison", "builtin", "of", "type", "BUILTIN_TYPE", ".", "ICODE", "is", "the", "code", "of", "the", "comparison", "instruction", "and", "COND", "is", "the", "condition", "it", "should", "test", ".", "ARGLIST", "is", "the", "list", "of", "function", "arguments", "and", "TARGET", ",", "if", "nonnull", ",", "suggests", "a", "good", "place", "to", "put", "the", "boolean", "result", "." ]

[ "mips", "0" ]

[]

[ "<s>", "AVRSubtarget", "&", "AVRSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "ParseSubtargetFeatures", "(", "CPU", ",", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR" ]

[]

[ "<s>", "void", "SparcTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Result", ";", "if", "(", "Constraint", ".", "length", "(", ")", ">", "1", ")", "return", ";", "char", "ConstraintLetter", "=", "Constraint", "[", "0", "]", ";", "switch", "(", "ConstraintLetter", ")", "{", "default", ":", "break", ";", "case", "'I'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "isInt", "<", "13", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "return", ";", "}", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "Sparc", "Sparc", "1", "0", "13" ]

[]

[ "<s>", "bool", "X86GenericDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "size", ",", "const", "MemoryObject", "&", "region", ",", "uint64_t", "address", ",", "raw_ostream", "&", "vStream", ")", "const", "{", "InternalInstruction", "internalInstr", ";", "int", "ret", "=", "decodeInstruction", "(", "&", "internalInstr", ",", "regionReader", ",", "(", "void", "*", ")", "&", "region", ",", "logger", ",", "(", "void", "*", ")", "&", "vStream", ",", "address", ",", "fMode", ")", ";", "if", "(", "ret", ")", "{", "size", "=", "internalInstr", ".", "readerCursor", "-", "address", ";", "return", "false", ";", "}", "else", "{", "size", "=", "internalInstr", ".", "length", ";", "return", "!", "translateInstruction", "(", "instr", ",", "internalInstr", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ")", "const", "{", "assert", "(", "(", "(", "Val", "&&", "!", "VRegs", ".", "empty", "(", ")", ")", "||", "(", "!", "Val", "&&", "VRegs", ".", "empty", "(", ")", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "X86", "::", "RET", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "Val", "->", "getType", "(", ")", "->", "getContext", "(", ")", ";", "const", "X86TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "X86TargetLowering", ">", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitEVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "Val", "->", "getType", "(", ")", ",", "SplitEVTs", ")", ";", "assert", "(", "VRegs", ".", "size", "(", ")", "==", "SplitEVTs", ".", "size", "(", ")", "&&", "\"For each split Type there should be exactly one VReg.\"", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SplitEVTs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "ArgInfo", "CurArgInfo", "=", "ArgInfo", "{", "VRegs", "[", "i", "]", ",", "SplitEVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", "}", ";", "setArgFlags", "(", "CurArgInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "if", "(", "!", "splitToValueTypes", "(", "CurArgInfo", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "Register", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildUnmerge", "(", "Regs", ",", "VRegs", "[", "i", "]", ")", ";", "}", ")", ")", "return", "false", ";", "}", "X86OutgoingValueHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetCC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "X86", "X86", "\"Return value without a vreg\"", "X86::RET", "0", "X86", "X86", "4", "\"For each split Type there should be exactly one VReg.\"", "8", "0", "X86", "X86" ]

[]

[ "<s>", "static", "bool", "ia64_cannot_force_const_mem", "(", "rtx", "x", ")", "{", "return", "tls_symbolic_operand_type", "(", "x", ")", "!=", "0", ";", "}", "</s>" ]

[ "Do", "n't", "allow", "TLS", "addresses", "to", "get", "spilled", "to", "memory", "." ]

[ "ia64", "0" ]

[]

[ "<s>", "const", "char", "*", "host_detect_local_cpu", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "cpu", "=", "NULL", ";", "const", "char", "*", "cache", "=", "\"\"", ";", "const", "char", "*", "options", "=", "\"\"", ";", "bool", "arch", ";", "bool", "assembler", ";", "size_t", "i", ";", "if", "(", "argc", "<", "1", ")", "return", "NULL", ";", "arch", "=", "strcmp", "(", "argv", "[", "0", "]", ",", "\"cpu\"", ")", "==", "0", ";", "assembler", "=", "(", "!", "arch", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"asm\"", ")", "==", "0", ")", ";", "if", "(", "!", "arch", "&&", "!", "assembler", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"tune\"", ")", ")", "return", "NULL", ";", "if", "(", "!", "assembler", ")", "{", "cache", "=", "detect_caches_aix", "(", ")", ";", "cache", "=", "detect_caches_darwin", "(", ")", ";", "cache", "=", "detect_caches_freebsd", "(", ")", ";", "cache", "=", "\"\"", ";", "cache", "=", "detect_caches_linux", "(", ")", ";", "cache", "=", "\"\"", ";", "cache", "=", "\"\"", ";", "}", "cpu", "=", "detect_processor_aix", "(", ")", ";", "cpu", "=", "detect_processor_darwin", "(", ")", ";", "cpu", "=", "detect_processor_freebsd", "(", ")", ";", "cpu", "=", "detect_processor_linux", "(", ")", ";", "cpu", "=", "\"powerpc\"", ";", "if", "(", "assembler", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "asm_names", ")", ";", "i", "++", ")", "{", "if", "(", "!", "asm_names", "[", "i", "]", ".", "cpu", "||", "!", "strcmp", "(", "asm_names", "[", "i", "]", ".", "cpu", ",", "cpu", ")", ")", "return", "asm_names", "[", "i", "]", ".", "asm_sw", ";", "}", "return", "NULL", ";", "}", "return", "concat", "(", "cache", ",", "\"-m\"", ",", "argv", "[", "0", "]", ",", "\"=\"", ",", "cpu", ",", "\" \"", ",", "options", ",", "NULL", ")", ";", "}", "</s>" ]

[ "This", "will", "be", "called", "by", "the", "spec", "parser", "in", "gcc.cc", "when", "it", "sees", "a", "%", ":", "local_cpu_detect", "(", "args", ")", "construct", ".", "Currently", "it", "will", "be", "called", "with", "either", "``", "cpu", "''", "or", "``", "tune", "''", "as", "argument", "depending", "on", "if", "-mcpu=native", "or", "-mtune=native", "is", "to", "be", "substituted", ".", "It", "returns", "a", "string", "containing", "new", "command", "line", "parameters", "to", "be", "put", "at", "the", "place", "of", "the", "above", "two", "options", ",", "depending", "on", "what", "CPU", "this", "is", "executed", ".", "E.g", ".", "``", "-mcpu=ultrasparc3", "''", "on", "an", "UltraSPARC", "III", "for", "-mcpu=native", ".", "If", "the", "routine", "ca", "n't", "detect", "a", "known", "processor", ",", "the", "-mcpu", "or", "-mtune", "option", "is", "discarded", ".", "ARGC", "and", "ARGV", "are", "set", "depending", "on", "the", "actual", "arguments", "given", "in", "the", "spec", "." ]

[ "rs6000", "\"\"", "\"\"", "1", "0", "\"cpu\"", "0", "0", "\"asm\"", "0", "0", "\"tune\"", "\"\"", "\"\"", "\"\"", "\"powerpc\"", "0", "\"-m\"", "0", "\"=\"", "\" \"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "LegalFPImmediates", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "Imm", ".", "bitwiseIsEqual", "(", "LegalFPImmediates", "[", "i", "]", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

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

[]

[ "<s>", "EVT", "BPFTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "return", "getHasAlu32", "(", ")", "?", "MVT", "::", "i32", ":", "MVT", "::", "i64", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "MVT::i32", "MVT::i64" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "MSP430Operand", ">", "CreateMem", "(", "unsigned", "RegNum", ",", "const", "MCExpr", "*", "Val", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "return", "make_unique", "<", "MSP430Operand", ">", "(", "RegNum", ",", "Val", ",", "S", ",", "E", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "FeatureBitset", "&", "getFeatures", "(", ")", "const", "{", "return", "Features", ";", "}", "</s>" ]

[ "Returns", "the", "vector", "of", "individual", "subtarget", "features", "." ]

[ "Mips" ]

[]

[ "<s>", "bool", "arc_store_addr_hazard_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "in_set", ",", "out_set", ";", "rtx", "out_addr", ",", "in_addr", ";", "if", "(", "!", "producer", ")", "return", "false", ";", "if", "(", "!", "consumer", ")", "return", "false", ";", "out_set", "=", "single_set", "(", "producer", ")", ";", "if", "(", "out_set", ")", "{", "out_addr", "=", "SET_DEST", "(", "out_set", ")", ";", "if", "(", "!", "out_addr", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "out_addr", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "out_addr", ")", "==", "SIGN_EXTEND", ")", "out_addr", "=", "XEXP", "(", "out_addr", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "out_addr", ")", ")", "return", "false", ";", "in_set", "=", "single_set", "(", "consumer", ")", ";", "if", "(", "in_set", ")", "{", "in_addr", "=", "SET_SRC", "(", "in_set", ")", ";", "if", "(", "!", "in_addr", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "in_addr", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "in_addr", ")", "==", "SIGN_EXTEND", ")", "in_addr", "=", "XEXP", "(", "in_addr", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "in_addr", ")", ")", "return", "false", ";", "in_addr", "=", "XEXP", "(", "in_addr", ",", "0", ")", ";", "out_addr", "=", "XEXP", "(", "out_addr", ",", "0", ")", ";", "return", "exp_equiv_p", "(", "in_addr", ",", "out_addr", ",", "0", ",", "true", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "load", "instruction", "(", "CONSUMER", ")", "uses", "the", "same", "address", "as", "a", "store", "instruction", "(", "PRODUCER", ")", ".", "This", "function", "is", "used", "to", "avoid", "st/ld", "address", "hazard", "in", "ARC700", "cores", "." ]

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

[]

[ "<s>", "static", "void", "ix86_output_indirect_branch_via_push", "(", "rtx", "call_op", ",", "const", "char", "*", "xasm", ",", "bool", "sibcall_p", ")", "{", "char", "thunk_name_buf", "[", "32", "]", ";", "char", "*", "thunk_name", ";", "char", "push_buf", "[", "64", "]", ";", "enum", "indirect_thunk_prefix", "need_prefix", "=", "indirect_thunk_need_prefix", "(", "current_output_insn", ")", ";", "int", "regno", "=", "-", "1", ";", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "!=", "indirect_branch_thunk_inline", ")", "{", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk", ")", "{", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "indirect_thunk_bnd_needed", "=", "true", ";", "else", "indirect_thunk_needed", "=", "true", ";", "}", "indirect_thunk_name", "(", "thunk_name_buf", ",", "regno", ",", "need_prefix", ",", "false", ")", ";", "thunk_name", "=", "thunk_name_buf", ";", "}", "else", "thunk_name", "=", "NULL", ";", "snprintf", "(", "push_buf", ",", "sizeof", "(", "push_buf", ")", ",", "\"push{%c}\\t%s\"", ",", "TARGET_64BIT", "?", "'q'", ":", "'l'", ",", "xasm", ")", ";", "if", "(", "sibcall_p", ")", "{", "output_asm_insn", "(", "push_buf", ",", "&", "call_op", ")", ";", "if", "(", "thunk_name", "!=", "NULL", ")", "{", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tbnd jmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "}", "else", "output_indirect_thunk", "(", "need_prefix", ",", "regno", ")", ";", "}", "else", "{", "char", "indirectlabel1", "[", "32", "]", ";", "char", "indirectlabel2", "[", "32", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel1", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel2", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "fputs", "(", "\"\\tbnd jmp\\t\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\tjmp\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "if", "(", "MEM_P", "(", "call_op", ")", ")", "{", "struct", "ix86_address", "parts", ";", "rtx", "addr", "=", "XEXP", "(", "call_op", ",", "0", ")", ";", "if", "(", "ix86_decompose_address", "(", "addr", ",", "&", "parts", ")", "&&", "parts", ".", "base", "==", "stack_pointer_rtx", ")", "{", "if", "(", "parts", ".", "index", ")", "{", "addr", "=", "gen_rtx_MULT", "(", "Pmode", ",", "parts", ".", "index", ",", "GEN_INT", "(", "parts", ".", "scale", ")", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "addr", ")", ";", "}", "else", "addr", "=", "stack_pointer_rtx", ";", "rtx", "disp", ";", "if", "(", "parts", ".", "disp", "!=", "NULL_RTX", ")", "disp", "=", "plus_constant", "(", "Pmode", ",", "parts", ".", "disp", ",", "UNITS_PER_WORD", ")", ";", "else", "disp", "=", "GEN_INT", "(", "UNITS_PER_WORD", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ",", "disp", ")", ";", "call_op", "=", "gen_rtx_MEM", "(", "GET_MODE", "(", "call_op", ")", ",", "addr", ")", ";", "}", "}", "output_asm_insn", "(", "push_buf", ",", "&", "call_op", ")", ";", "if", "(", "thunk_name", "!=", "NULL", ")", "{", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tbnd jmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "}", "else", "output_indirect_thunk", "(", "need_prefix", ",", "regno", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "fputs", "(", "\"\\tbnd call\\t\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\tcall\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "}", "</s>" ]

[ "Output", "indirect", "branch", "via", "a", "call", "and", "return", "thunk", ".", "CALL_OP", "is", "the", "branch", "target", ".", "XASM", "is", "the", "assembly", "template", "for", "CALL_OP", ".", "Branch", "is", "a", "tail", "call", "if", "SIBCALL_P", "is", "true", ".", "A", "normal", "call", "is", "converted", "to", ":", "jmp", "L2", "L1", ":", "push", "CALL_OP", "jmp", "__x86_indirect_thunk", "L2", ":", "call", "L1", "and", "a", "tail", "call", "is", "converted", "to", ":", "push", "CALL_OP", "jmp", "__x86_indirect_thunk" ]

[ "i386", "32", "64", "1", "\"push{%c}\\t%s\"", "\"\\tbnd jmp\\t%s\\n\"", "\"\\tjmp\\t%s\\n\"", "32", "32", "\"\\tbnd jmp\\t\"", "\"\\tjmp\\t\"", "0", "\"\\tbnd jmp\\t%s\\n\"", "\"\\tjmp\\t%s\\n\"", "\"\\tbnd call\\t\"", "\"\\tcall\\t\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "analyzeBranchPredicate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBranchPredicate", "&", "MBP", ",", "bool", "AllowModify", ")", "const", "{", "using", "namespace", "std", "::", "placeholders", ";", "SmallVector", "<", "MachineOperand", ",", "4", ">", "Cond", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "CondBranches", ";", "if", "(", "AnalyzeBranchImpl", "(", "MBB", ",", "MBP", ".", "TrueDest", ",", "MBP", ".", "FalseDest", ",", "Cond", ",", "CondBranches", ",", "AllowModify", ")", ")", "return", "true", ";", "if", "(", "Cond", ".", "size", "(", ")", "!=", "1", ")", "return", "true", ";", "assert", "(", "MBP", ".", "TrueDest", "&&", "\"expected!\"", ")", ";", "if", "(", "!", "MBP", ".", "FalseDest", ")", "MBP", ".", "FalseDest", "=", "MBB", ".", "getNextNode", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "MachineInstr", "*", "ConditionDef", "=", "nullptr", ";", "bool", "SingleUseCondition", "=", "true", ";", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "drop_begin", "(", "llvm", "::", "reverse", "(", "MBB", ")", ")", ")", "{", "if", "(", "MI", ".", "modifiesRegister", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ")", "{", "ConditionDef", "=", "&", "MI", ";", "break", ";", "}", "if", "(", "MI", ".", "readsRegister", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ")", "SingleUseCondition", "=", "false", ";", "}", "if", "(", "!", "ConditionDef", ")", "return", "true", ";", "if", "(", "SingleUseCondition", ")", "{", "for", "(", "auto", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "if", "(", "Succ", "->", "isLiveIn", "(", "X86", "::", "EFLAGS", ")", ")", "SingleUseCondition", "=", "false", ";", "}", "MBP", ".", "ConditionDef", "=", "ConditionDef", ";", "MBP", ".", "SingleUseCondition", "=", "SingleUseCondition", ";", "const", "unsigned", "TestOpcode", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "X86", "::", "TEST64rr", ":", "X86", "::", "TEST32rr", ";", "if", "(", "ConditionDef", "->", "getOpcode", "(", ")", "==", "TestOpcode", "&&", "ConditionDef", "->", "getNumOperands", "(", ")", "==", "3", "&&", "ConditionDef", "->", "getOperand", "(", "0", ")", ".", "isIdenticalTo", "(", "ConditionDef", "->", "getOperand", "(", "1", ")", ")", "&&", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "==", "X86", "::", "COND_NE", "||", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "==", "X86", "::", "COND_E", ")", ")", "{", "MBP", ".", "LHS", "=", "ConditionDef", "->", "getOperand", "(", "0", ")", ";", "MBP", ".", "RHS", "=", "MachineOperand", "::", "CreateImm", "(", "0", ")", ";", "MBP", ".", "Predicate", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "==", "X86", "::", "COND_NE", "?", "MachineBranchPredicate", "::", "PRED_NE", ":", "MachineBranchPredicate", "::", "PRED_EQ", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", "and", "parse", "it", "into", "the", "MachineBranchPredicate", "structure", "if", "possible", "." ]

[ "X86", "X86", "4", "4", "1", "\"expected!\"", "X86::EFLAGS", "X86::EFLAGS", "X86::EFLAGS", "X86::TEST64rr", "X86::TEST32rr", "3", "0", "1", "0", "X86::COND_NE", "0", "X86::COND_E", "0", "0", "0", "X86::COND_NE" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "&&", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "0", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "1", ";", "--", "I", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "1", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "RISCV", "RISCV", "0", "0", "0", "1", "1", "2" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "ARM64TargetLowering", "::", "getScratchRegisters", "(", "CallingConv", "::", "ID", ")", "const", "{", "static", "const", "MCPhysReg", "ScratchRegs", "[", "]", "=", "{", "ARM64", "::", "X16", ",", "ARM64", "::", "X17", ",", "ARM64", "::", "LR", ",", "0", "}", ";", "return", "ScratchRegs", ";", "}", "</s>" ]

[ "Returns", "a", "0", "terminated", "array", "of", "registers", "that", "can", "be", "safely", "used", "as", "scratch", "registers", "." ]

[ "ARM64", "ARM64", "ARM64::X16", "ARM64::X17", "ARM64::LR", "0" ]

[]

[ "<s>", "static", "void", "sh_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "sh2a_function_vector_p", "(", "decl", ")", "&&", "TARGET_SH2A", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "|=", "SYMBOL_FLAG_FUNCVEC_FUNCTION", ";", "}", "</s>" ]

[ "Encode", "symbol", "attributes", "of", "a", "SYMBOL_REF", "into", "its", "SYMBOL_REF_FLAGS", "." ]

[ "sh", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Lower aggregate copies/intrinsics into loops\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"Lower aggregate copies/intrinsics into loops\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "unsigned", "NumBits1", "=", "VT1", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumBits2", "=", "VT2", ".", "getSizeInBits", "(", ")", ";", "if", "(", "NumBits1", "<=", "NumBits2", ")", "return", "false", ";", "return", "Subtarget", "->", "is64Bit", "(", ")", "||", "NumBits1", "<", "64", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

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

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "dump", "(", ")", "{", "errs", "(", ")", "<<", "\"MSP430ISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "if", "(", "BaseType", "==", "RegBase", "&&", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "nullptr", ")", "{", "errs", "(", ")", "<<", "\"Base.Reg \"", ";", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "{", "errs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base", ".", "FrameIndex", "<<", "'\\n'", ";", "}", "errs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", ";", "if", "(", "GV", ")", "{", "errs", "(", ")", "<<", "\"GV \"", ";", "GV", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "CP", ")", "{", "errs", "(", ")", "<<", "\" CP \"", ";", "CP", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "else", "if", "(", "ES", ")", "{", "errs", "(", ")", "<<", "\"ES \"", ";", "errs", "(", ")", "<<", "ES", "<<", "'\\n'", ";", "}", "else", "if", "(", "JT", "!=", "-", "1", ")", "errs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "MSP430", "\"MSP430ISelAddressMode \"", "\"Base.Reg \"", "\" Base.FrameIndex \"", "\" Disp \"", "\"GV \"", "\" CP \"", "\" Align\"", "\"ES \"", "1", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "MipsTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "Subtarget", ".", "hasMSA", "(", ")", "&&", "type", "->", "isVectorTy", "(", ")", "&&", "type", "->", "getPrimitiveSizeInBits", "(", ")", ".", "getFixedSize", "(", ")", "==", "128", ")", "weight", "=", "CW_Register", ";", "else", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'c'", ":", "case", "'l'", ":", "case", "'x'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_SpecificReg", ";", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "if", "(", "isa", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'R'", ":", "weight", "=", "CW_Memory", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "xtensa_function_incoming_arg", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "xtensa_function_arg_1", "(", "cum", ",", "arg", ",", "true", ")", ";", "}", "</s>" ]

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

[ "xtensa" ]

[]

[ "<s>", "void", "addInst", "(", "MachineInstr", "*", "MI", ",", "SetVector", "<", "MachineInstr", "*", ">", "&", "Preds", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM Loops: Adding predicated MI: \"", "<<", "*", "MI", ")", ";", "if", "(", "!", "Divergent", "&&", "!", "set_difference", "(", "Preds", ",", "VPST", "->", "Predicates", ")", ".", "empty", "(", ")", ")", "{", "Divergent", "=", "&", "Insts", ".", "back", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" - has divergent predicate: \"", "<<", "*", "Divergent", "->", "MI", ")", ";", "}", "Insts", ".", "emplace_back", "(", "MI", ",", "Preds", ")", ";", "assert", "(", "Insts", ".", "size", "(", ")", "<=", "4", "&&", "\"Too many instructions in VPT block!\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM Loops: Adding predicated MI: \"", "\" - has divergent predicate: \"", "4", "\"Too many instructions in VPT block!\"" ]

[]

[ "<s>", "static", "MipsABIInfo", "Unknown", "(", ")", "{", "return", "MipsABIInfo", "(", "ABI", "::", "Unknown", ")", ";", "}", "</s>" ]

[ "The", "kind", "of", "location", "description", "being", "produced", ".", "More", "..." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Always Inline Pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Always Inline Pass\"" ]

[]

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

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

[ "J2", "J2" ]

[]

[ "<s>", "bool", "SystemZTTIImpl", "::", "hasDivRemOp", "(", "Type", "*", "DataType", ",", "bool", "IsSigned", ")", "{", "EVT", "VT", "=", "TLI", "->", "getValueType", "(", "DL", ",", "DataType", ")", ";", "return", "(", "VT", ".", "isScalarInteger", "(", ")", "&&", "TLI", "->", "isTypeLegal", "(", "VT", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "a", "unified", "operation", "to", "calculate", "division", "and", "remainder", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "int", "sparc_split_reg_reg_legitimate", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "gcc_assert", "(", "reload_completed", ")", ";", "if", "(", "GET_CODE", "(", "reg1", ")", "==", "SUBREG", ")", "reg1", "=", "SUBREG_REG", "(", "reg1", ")", ";", "if", "(", "GET_CODE", "(", "reg1", ")", "!=", "REG", ")", "return", "0", ";", "const", "int", "regno1", "=", "REGNO", "(", "reg1", ")", ";", "if", "(", "GET_CODE", "(", "reg2", ")", "==", "SUBREG", ")", "reg2", "=", "SUBREG_REG", "(", "reg2", ")", ";", "if", "(", "GET_CODE", "(", "reg2", ")", "!=", "REG", ")", "return", "0", ";", "const", "int", "regno2", "=", "REGNO", "(", "reg2", ")", ";", "if", "(", "SPARC_INT_REG_P", "(", "regno1", ")", "&&", "SPARC_INT_REG_P", "(", "regno2", ")", ")", "return", "1", ";", "if", "(", "TARGET_VIS3", ")", "{", "if", "(", "(", "SPARC_INT_REG_P", "(", "regno1", ")", "&&", "SPARC_FP_REG_P", "(", "regno2", ")", ")", "||", "(", "SPARC_FP_REG_P", "(", "regno1", ")", "&&", "SPARC_INT_REG_P", "(", "regno2", ")", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Like", "sparc_split_reg_mem_legitimate", "but", "for", "REG", "<", "--", ">", "REG", "moves", "." ]

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

[]

[ "<s>", "unsigned", "SystemZInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SystemZ", "::", "MOV32rm", ":", "case", "SystemZ", "::", "MOV32rmy", ":", "case", "SystemZ", "::", "MOV64rm", ":", "case", "SystemZ", "::", "MOVSX32rm8", ":", "case", "SystemZ", "::", "MOVSX32rm16y", ":", "case", "SystemZ", "::", "MOVSX64rm8", ":", "case", "SystemZ", "::", "MOVSX64rm16", ":", "case", "SystemZ", "::", "MOVSX64rm32", ":", "case", "SystemZ", "::", "MOVZX32rm8", ":", "case", "SystemZ", "::", "MOVZX32rm16", ":", "case", "SystemZ", "::", "MOVZX64rm8", ":", "case", "SystemZ", "::", "MOVZX64rm16", ":", "case", "SystemZ", "::", "MOVZX64rm32", ":", "case", "SystemZ", "::", "FMOV32rm", ":", "case", "SystemZ", "::", "FMOV32rmy", ":", "case", "SystemZ", "::", "FMOV64rm", ":", "case", "SystemZ", "::", "FMOV64rmy", ":", "case", "SystemZ", "::", "MOV64Prm", ":", "case", "SystemZ", "::", "MOV64Prmy", ":", "case", "SystemZ", "::", "MOV128rm", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "SystemZ", "SystemZ", "SystemZ::MOV32rm", "SystemZ::MOV32rmy", "SystemZ::MOV64rm", "SystemZ::MOVSX32rm8", "SystemZ::MOVSX32rm16y", "SystemZ::MOVSX64rm8", "SystemZ::MOVSX64rm16", "SystemZ::MOVSX64rm32", "SystemZ::MOVZX32rm8", "SystemZ::MOVZX32rm16", "SystemZ::MOVZX64rm8", "SystemZ::MOVZX64rm16", "SystemZ::MOVZX64rm32", "SystemZ::FMOV32rm", "SystemZ::FMOV32rmy", "SystemZ::FMOV64rm", "SystemZ::FMOV64rmy", "SystemZ::MOV64Prm", "SystemZ::MOV64Prmy", "SystemZ::MOV128rm", "1", "2", "3", "2", "0", "3", "0", "1", "0", "0" ]

[]

[ "<s>", "std", "::", "string", "str", "(", ")", "const", "{", "std", "::", "string", "S", ";", "raw_string_ostream", "OS", "(", "S", ")", ";", "OS", "<<", "\"{\"", ";", "StartInst", "->", "print", "(", "OS", ",", "NULL", ",", "true", ")", ";", "OS", "<<", "\" -> \"", ";", "LastInst", "->", "print", "(", "OS", ",", "NULL", ",", "true", ")", ";", "if", "(", "KillInst", ")", "{", "OS", "<<", "\" (kill @ \"", ";", "KillInst", "->", "print", "(", "OS", ",", "NULL", ",", "true", ")", ";", "OS", "<<", "\")\"", ";", "}", "OS", "<<", "\"}\"", ";", "return", "OS", ".", "str", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "twine", "contents", "as", "a", "std", ":", ":string", "." ]

[ "AArch64", "\"{\"", "\" -> \"", "\" (kill @ \"", "\")\"", "\"}\"" ]

[]

[ "<s>", "TargetPassConfig", "*", "ARMBaseTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "ARMPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ARCInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "assert", "(", "MMO", "&&", "\"Couldn't get MachineMemOperand for store to stack.\"", ")", ";", "assert", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "==", "4", "&&", "\"Only support 4-byte loads from stack now.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "\"Only support GPR32 stores to stack now.\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created load reg=\"", "<<", "printReg", "(", "DestReg", ",", "TRI", ")", "<<", "\" from FrameIndex=\"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARC", "::", "LD_rs9", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Couldn't get MachineMemOperand for store to stack.\"", "4", "\"Only support 4-byte loads from stack now.\"", "ARC::GPR32RegClass", "\"Only support GPR32 stores to stack now.\"", "\"Created load reg=\"", "\" from FrameIndex=\"", "\"\\n\"", "ARC::LD_rs9", "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", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "combineINTRINSIC", "(", "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", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_VOID" ]

[]

[ "<s>", "static", "void", "ia64_option_override", "(", "void", ")", "{", "unsigned", "int", "i", ";", "cl_deferred_option", "*", "opt", ";", "vec", "<", "cl_deferred_option", ">", "*", "v", "=", "(", "vec", "<", "cl_deferred_option", ">", "*", ")", "ia64_deferred_options", ";", "if", "(", "v", ")", "FOR_EACH_VEC_ELT", "(", "*", "v", ",", "i", ",", "opt", ")", "{", "switch", "(", "opt", "->", "opt_index", ")", "{", "case", "OPT_mfixed_range_", ":", "fix_range", "(", "opt", "->", "arg", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "TARGET_AUTO_PIC", ")", "target_flags", "|=", "MASK_CONST_GP", ";", "if", "(", "optimize", ">=", "3", ")", "flag_ira_loop_pressure", "=", "1", ";", "ia64_section_threshold", "=", "(", "global_options_set", ".", "x_g_switch_value", "?", "g_switch_value", ":", "IA64_DEFAULT_GVALUE", ")", ";", "init_machine_status", "=", "ia64_init_machine_status", ";", "if", "(", "align_functions", "<=", "0", ")", "align_functions", "=", "64", ";", "if", "(", "align_loops", "<=", "0", ")", "align_loops", "=", "32", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "flag_no_common", "=", "1", ";", "ia64_override_options_after_change", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "ia64", "3", "1", "0", "64", "0", "32", "1" ]

[]

[ "<s>", "void", "HexagonMCCodeEmitter", "::", "encodeInstruction", "(", "MCInst", "const", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "const", "{", "MCInst", "&", "HMB", "=", "const_cast", "<", "MCInst", "&", ">", "(", "MI", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "HMB", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Encoding bundle\\n\"", ";", ")", ";", "*", "Addend", "=", "0", ";", "*", "Extended", "=", "false", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "size_t", "Instruction", "=", "0", ";", "size_t", "Last", "=", "HexagonMCInstrInfo", "::", "bundleSize", "(", "HMB", ")", "-", "1", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "HMB", ")", ")", "{", "MCInst", "&", "HMI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "*", "I", ".", "getInst", "(", ")", ")", ";", "EncodeSingleInstruction", "(", "HMI", ",", "OS", ",", "Fixups", ",", "STI", ",", "parseBits", "(", "Instruction", ",", "Last", ",", "HMB", ",", "HMI", ")", ",", "Instruction", ")", ";", "*", "Extended", "=", "HexagonMCInstrInfo", "::", "isImmext", "(", "HMI", ")", ";", "*", "Addend", "+=", "HEXAGON_INSTR_SIZE", ";", "++", "Instruction", ";", "}", "return", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "\"Encoding bundle\\n\"", "0", "0", "Hexagon", "1", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "Z80oldSubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old" ]

[]

[ "<s>", "void", "KudeyarFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "KudeyarMachineFunctionInfo", "*", "KudeyarFI", "=", "MF", ".", "getInfo", "<", "KudeyarMachineFunctionInfo", ">", "(", ")", ";", "const", "KudeyarInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "KudeyarInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "Kudeyar", "::", "RET", ":", "case", "Kudeyar", "::", "RETI", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "KudeyarFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "4", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "POP_R", ")", ",", "Kudeyar", "::", "FP", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "prior", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "Kudeyar", "::", "POP_R", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "MOV_RR", ")", ",", "Kudeyar", "::", "SP", ")", ".", "addReg", "(", "Kudeyar", "::", "FP", ")", ";", "if", "(", "CSSize", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "SUB_RI32", ")", ",", "Kudeyar", "::", "SP", ")", ".", "addReg", "(", "Kudeyar", "::", "SP", ")", ".", "addImm", "(", "CSSize", ")", ";", "}", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "ADD_RI32", ")", ",", "Kudeyar", "::", "SP", ")", ".", "addReg", "(", "Kudeyar", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar::RET", "Kudeyar::RETI", "\"Can only insert epilog into returning blocks\"", "Kudeyar", "0", "4", "Kudeyar::POP_R", "Kudeyar::FP", "Kudeyar::POP_R", "Kudeyar::MOV_RR", "Kudeyar::SP", "Kudeyar::FP", "Kudeyar::SUB_RI32", "Kudeyar::SP", "Kudeyar::SP", "Kudeyar::ADD_RI32", "Kudeyar::SP", "Kudeyar::SP" ]

[]

[ "<s>", "SDNode", "*", "SparcDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "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", "int", "riscv_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "(", "from", "==", "FP_REGS", "&&", "to", "==", "GR_REGS", ")", "||", "(", "from", "==", "GR_REGS", "&&", "to", "==", "FP_REGS", ")", ")", "return", "tune_param", "->", "fmv_cost", ";", "return", "riscv_secondary_memory_needed", "(", "mode", ",", "from", ",", "to", ")", "?", "8", ":", "2", ";", "}", "</s>" ]

[ "Implement", "TARGET_REGISTER_MOVE_COST", "." ]

[ "riscv", "8", "2" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "override", "{", "if", "(", "(", "Count", "%", "2", ")", "!=", "0", ")", "{", "return", "false", ";", "}", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "2", ")", "{", "OS", ".", "write", "(", "0x00", ")", ";", "OS", ".", "write", "(", "0x01", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AAP", "2", "0", "0", "2", "0x00", "0x01" ]

[]

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

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

[ "Alpha", "\"Alpha Branch Selection\"" ]

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "isARMLowRegister", "(", "SrcReg", ")", ")", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "isARMLowRegister", "(", "SrcReg", ")", ")", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tSpill", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM::tGPRRegisterClass", "ARM", "\"Unknown regclass!\"", "ARM::tGPRRegisterClass", "ARM", "0", "ARM::tSpill", "0" ]

[]

[ "<s>", "static", "void", "ix86_adjust_counter", "(", "rtx", "countreg", ",", "HOST_WIDE_INT", "value", ")", "{", "emit_insn", "(", "gen_add2_insn", "(", "countreg", ",", "GEN_INT", "(", "-", "value", ")", ")", ")", ";", "}", "</s>" ]

[ "Adjust", "COUNTER", "by", "the", "VALUE", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "legitimate_scaled_address_p", "(", "machine_mode", "mode", ",", "rtx", "op", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "!=", "MULT", ")", "return", "false", ";", "if", "(", "!", "RTX_OK_FOR_INDEX_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ",", "strict", ")", ")", "return", "false", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "2", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "2", ")", "return", "false", ";", "break", ";", "case", "8", ":", "if", "(", "!", "TARGET_LL64", ")", "return", "false", ";", "case", "4", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "4", ")", "return", "false", ";", "default", ":", "return", "false", ";", "}", "if", "(", "RTX_OK_FOR_BASE_P", "(", "XEXP", "(", "op", ",", "1", ")", ",", "(", "strict", ")", ")", ")", "return", "true", ";", "if", "(", "flag_pic", ")", "{", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "TRUE", "if", "op", "is", "an", "scaled", "address", "." ]

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

[]

[ "<s>", "void", "Warning", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "getParser", "(", ")", ".", "Warning", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Emit", "a", "warning", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasAVX", "(", ")", "||", "!", "ST", ".", "insertVZEROUPPER", "(", ")", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "EverMadeChange", "=", "false", ";", "IsX86INTR", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_INTR", ";", "bool", "FnHasLiveInYmmOrZmm", "=", "checkFnHasLiveInYmmOrZmm", "(", "MRI", ")", ";", "bool", "YmmOrZmmUsed", "=", "FnHasLiveInYmmOrZmm", ";", "for", "(", "auto", "*", "RC", ":", "{", "&", "X86", "::", "VR256RegClass", ",", "&", "X86", "::", "VR512_0_15RegClass", "}", ")", "{", "if", "(", "!", "YmmOrZmmUsed", ")", "{", "for", "(", "TargetRegisterClass", "::", "iterator", "i", "=", "RC", "->", "begin", "(", ")", ",", "e", "=", "RC", "->", "end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "!", "MRI", ".", "reg_nodbg_empty", "(", "*", "i", ")", ")", "{", "YmmOrZmmUsed", "=", "true", ";", "break", ";", "}", "}", "}", "}", "if", "(", "!", "YmmOrZmmUsed", ")", "return", "false", ";", "assert", "(", "BlockStates", ".", "empty", "(", ")", "&&", "DirtySuccessors", ".", "empty", "(", ")", "&&", "\"X86VZeroUpper state should be clear\"", ")", ";", "BlockStates", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MBB", ")", ";", "if", "(", "FnHasLiveInYmmOrZmm", ")", "addDirtySuccessor", "(", "MF", ".", "front", "(", ")", ")", ";", "while", "(", "!", "DirtySuccessors", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "DirtySuccessors", ".", "back", "(", ")", ";", "DirtySuccessors", ".", "pop_back", "(", ")", ";", "BlockState", "&", "BBState", "=", "BlockStates", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "if", "(", "BBState", ".", "FirstUnguardedCall", "!=", "MBB", ".", "end", "(", ")", ")", "insertVZeroUpper", "(", "BBState", ".", "FirstUnguardedCall", ",", "MBB", ")", ";", "if", "(", "BBState", ".", "ExitState", "==", "PASS_THROUGH", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB #\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\" was Pass-through, is now Dirty-out.\\n\"", ")", ";", "for", "(", "MachineBasicBlock", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "addDirtySuccessor", "(", "*", "Succ", ")", ";", "}", "}", "BlockStates", ".", "clear", "(", ")", ";", "return", "EverMadeChange", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "TL45Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "TL45", "TL45" ]

[]

[ "<s>", "static", "void", "core2i7_first_cycle_multipass_end", "(", "const", "void", "*", "_data", ")", "{", "const_ix86_first_cycle_multipass_data_t", "data", "=", "(", "const_ix86_first_cycle_multipass_data_t", ")", "_data", ";", "ix86_first_cycle_multipass_data_t", "next_data", "=", "ix86_first_cycle_multipass_data", ";", "if", "(", "data", "!=", "NULL", ")", "{", "next_data", "->", "ifetch_block_len", "=", "data", "->", "ifetch_block_len", ";", "next_data", "->", "ifetch_block_n_insns", "=", "data", "->", "ifetch_block_n_insns", ";", "}", "}", "</s>" ]

[ "Save", "the", "result", "of", "multipass", "lookahead", "scheduling", "for", "the", "next", "round", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "aarch64_and_bitmask_imm", "(", "unsigned", "HOST_WIDE_INT", "val_in", ",", "machine_mode", "mode", ")", "{", "if", "(", "aarch64_bitmask_imm", "(", "val_in", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "aarch64_move_imm", "(", "val_in", ",", "mode", ")", ")", "return", "false", ";", "unsigned", "HOST_WIDE_INT", "imm2", "=", "aarch64_and_split_imm2", "(", "val_in", ")", ";", "return", "aarch64_bitmask_imm", "(", "imm2", ",", "mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "VAL_IN", "is", "a", "valid", "'and", "'", "bitmask", "immediate", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "*", "getAdjustedAnalysisPointer", "(", "const", "void", "*", "ID", ")", "override", "{", "if", "(", "ID", "==", "&", "TargetTransformInfo", "::", "ID", ")", "return", "(", "TargetTransformInfo", "*", ")", "this", ";", "return", "this", ";", "}", "</s>" ]

[ "getAdjustedAnalysisPointer", "-", "This", "method", "is", "used", "when", "a", "pass", "implements", "an", "analysis", "interface", "through", "multiple", "inheritance", "." ]

[ "PowerPC" ]

[]

[ "<s>", "SDNode", "*", "WDC65816DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "WDC_LOG", "(", "\"WDC_TODO - This method is probably implemented wrong...\"", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "WDC65816", "WDC", "WDC", "\"WDC_TODO - This method is probably implemented wrong...\"" ]

[]

[ "<s>", "static", "int", "mt_add_branches", "(", "rtx", "*", "x", ",", "void", "*", "insn", ")", "{", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "LABEL_REF", ")", "{", "branch_info", "*", "branch", "=", "xmalloc", "(", "sizeof", "(", "*", "branch", ")", ")", ";", "rtx", "label", "=", "XEXP", "(", "*", "x", ",", "0", ")", ";", "label_info", "*", "info", ";", "for", "(", "info", "=", "mt_labels", ";", "info", ";", "info", "=", "info", "->", "next", ")", "if", "(", "info", "->", "label", "==", "label", ")", "break", ";", "if", "(", "!", "info", ")", "{", "info", "=", "xmalloc", "(", "sizeof", "(", "*", "info", ")", ")", ";", "info", "->", "next", "=", "mt_labels", ";", "mt_labels", "=", "info", ";", "info", "->", "label", "=", "label", ";", "info", "->", "branches", "=", "NULL", ";", "}", "branch", "->", "next", "=", "info", "->", "branches", ";", "info", "->", "branches", "=", "branch", ";", "branch", "->", "insn", "=", "insn", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "If", "*", "X", "is", "a", "label", ",", "add", "INSN", "to", "the", "list", "of", "branches", "for", "that", "label", "." ]

[ "mt", "0", "0" ]

[]

[ "<s>", "bool", "aarch64_atomic_ldop_supported_p", "(", "enum", "rtx_code", "code", ")", "{", "if", "(", "!", "TARGET_LSE", ")", "return", "false", ";", "switch", "(", "code", ")", "{", "case", "SET", ":", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "MINUS", ":", "case", "PLUS", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Test", "whether", "the", "target", "supports", "using", "a", "atomic", "load-operate", "instruction", ".", "CODE", "is", "the", "operation", "and", "AFTER", "is", "TRUE", "if", "the", "data", "in", "memory", "after", "the", "operation", "should", "be", "returned", "and", "FALSE", "if", "the", "data", "before", "the", "operation", "should", "be", "returned", ".", "Returns", "FALSE", "if", "the", "operation", "is", "n't", "supported", "by", "the", "architecture", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "LC3InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "LC3", "::", "ADDrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "LC3", "LC3", "LC3::ADDrr", "0" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "reduceLoopCount", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "PreHeader", ",", "MachineInstr", "*", "IndVar", ",", "MachineInstr", "&", "Cmp", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "PrevInsts", ",", "unsigned", "Iter", ",", "unsigned", "MaxIter", ")", "const", "{", "assert", "(", "(", "!", "IndVar", ")", "&&", "isBDNZ", "(", "Cmp", ".", "getOpcode", "(", ")", ")", "&&", "\"Expecting a CTR loop\"", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "Cmp", ".", "getDebugLoc", "(", ")", ";", "MachineInstr", "*", "Loop", "=", "findLoopInstr", "(", "PreHeader", ")", ";", "if", "(", "!", "Loop", ")", "return", "0", ";", "Register", "LoopCountReg", "=", "Loop", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "LoopCount", "=", "MRI", ".", "getUniqueVRegDef", "(", "LoopCountReg", ")", ";", "if", "(", "!", "LoopCount", ")", "return", "0", ";", "if", "(", "LoopCount", "->", "getOpcode", "(", ")", "==", "PPC", "::", "LI8", "||", "LoopCount", "->", "getOpcode", "(", ")", "==", "PPC", "::", "LI", ")", "{", "int64_t", "Offset", "=", "LoopCount", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", "<=", "1", ")", "{", "LoopCount", "->", "eraseFromParent", "(", ")", ";", "Loop", "->", "eraseFromParent", "(", ")", ";", "return", "0", ";", "}", "LoopCount", "->", "getOperand", "(", "1", ")", ".", "setImm", "(", "Offset", "-", "1", ")", ";", "return", "Offset", "-", "1", ";", "}", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "CTR8", ":", "PPC", "::", "CTR", ",", "true", ")", ")", ";", "return", "LoopCountReg", ";", "}", "</s>" ]

[ "Generate", "code", "to", "reduce", "the", "loop", "iteration", "by", "one", "and", "check", "if", "the", "loop", "is", "finished", "." ]

[ "PowerPC", "PPC", "\"Expecting a CTR loop\"", "0", "0", "0", "PPC::LI8", "PPC::LI", "1", "1", "0", "1", "1", "1", "0", "PPC", "PPC::CTR8", "PPC::CTR" ]

[]